package qualomelhor.game;

import static playn.core.PlayN.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Random;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.sun.xml.internal.ws.wsdl.writer.UsingAddressing;

import playn.core.*;
import qualomelhor.database.Avatar;
import qualomelhor.database.Avatar.EstiloBoca;
import qualomelhor.database.Avatar.Cabelo;
import qualomelhor.database.Avatar.MovimentoSobrancelha;
import qualomelhor.database.Avatar.Olho;
import qualomelhor.database.Avatar.PosicaoBoca;
import qualomelhor.database.Avatar.PosicaoOlhoBoneco;
import qualomelhor.database.Avatar.Roupa;
import qualomelhor.database.Avatar.Sobrancelha;
import qualomelhor.database.ExpressaoDB;
import qualomelhor.database.SequenciaExpressaoDB;
import qualomelhor.database.PosicaoMaosDB;
import qualomelhor.gwt.modules.client.ClientUtils;
import qualomelhor.gwt.modules.client.ISessionSuportService;
import qualomelhor.gwt.modules.client.ISessionSuportServiceAsync;
import tripleplay.game.ScreenStack;

public class TestePlayN implements Game {

	private static HashMap<String, SequenciaExpressaoDB> mapSeqExpr = new HashMap<String, SequenciaExpressaoDB>(0);
	static {
		//ArrayList<ExpressaoDB> listExpressao = new ArrayList<ExpressaoDB>(0);
		//listExpressao.add(new ExpressaoDB(nome, pMaos, pOlho, posBoc, sobra, velocD, velocE, riscarD, riscarE, animar));
		//mapSeqExpr.put("", new SequenciaExpressaoDB(listExpressao, listTempoLoop, reestart, frameRestart, tempoRestart));
		//term, locale
		//mapTerm.put("Comparar 2 Itens_en_US", "Compare 2 things");
		/*
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		mapTerm.put("
		*/
	}

	class ObjImgPosicao {
		public ObjImgPosicao(ExpressaoDB exprDB, ImageLayer imgL) {
			this.exprDB = exprDB;
			this.imgL = imgL;
		}

		public ExpressaoDB exprDB;
		public ImageLayer imgL;
	};

	private ISessionSuportServiceAsync serviceSupportSvc = GWT.create(ISessionSuportService.class);

	//private static final int posXBracoE = 252;
	//private static final int posYBracoE = 190;
	private static final int posXBracoE = 252;
	private static final int posYBracoE = 190;
	private static final int posXBracoD = 366;
	private static final int posYBracoD = 190;

	private int xPosBoneco = 202;
	private int yPosBoneco = 60;

	private int xMovBackground = 0;
	private int yMovBackground = 0;

	private GroupLayer layerAvatar;
	private GroupLayer layerMaos;
	private GroupLayer layerCheeks;
	private CanvasImage bgtile;

	private ImageLayer[][] bgLayer;
	private ImageLayer lyCorpo;
	private ImageLayer lyCabelo;
	private ImageLayer lyRoupa;
	private ImageLayer lyCheekE;
	private ImageLayer lyCheekD;
	private ImageLayer text;
	private Image imgCorpo;
	private Image imgCabelo;
	private Image imgBoca;
	private Image imgRoupa;
	private Image imgMaoE;
	private Image imgMaoD;
	private Image imgCheeks;
	private Image imgBraco;
	private Avatar avatarAtual = ClientUtils.getRandomAvatar();
	private CanvasImage canvasImgDraw;
	private GroupLayer lyGrid;
	private GroupLayer lyDraw;
	private GroupLayer lyBalao;
	private GroupLayer lyTrocaAvatar;
	private CanvasImage cImgDraw = graphics().createImage(600, 300);
	private ImageLayer imgLayerDraw;
	private ArrayList<ObjImgPosicao> listImgDrawD = new ArrayList<ObjImgPosicao>(0);
	private ArrayList<ObjImgPosicao> listImgDrawE = new ArrayList<ObjImgPosicao>(0);

	private int piscaNum;
	private int numMov;
	private int posMEX;
	private int posMDX;
	private int posBEX;
	private int posBDX;
	private int errD;
	private int errE;
	private int posMEY;
	private int posMDY;
	private int posBEY;
	private int posBDY;
	private float rotacaoAdicionalMD = 0;
	private float rotacaoAdicionalME = 0;
	private TextAvatar textAvatar;
	private TrocaAvatar trocaAvatar;
	private Mao maoE;
	private Mao maoD;
	private Braco bracoE;
	private Braco bracoD;
	private Olhos olhos;
	private Boca boca;
	private Sobrancelhas sobrancelhas;
	private int maoAtualMouse = 1;
	private PosicaoMaosDB pMaosAtual = new PosicaoMaosDB("", 1, 1, 400, 200, 10, 10, 400, 190, 190, 190, 0, 0);
	private ExpressaoDB expressaoAtual = new ExpressaoDB("", new PosicaoMaosDB("", 1, 1, 100, 100, 300, 300, 130, 130, 130, 130, 0, 0), PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.FELIZ, MovimentoSobrancelha.SOBRANCELHA_PARADA, 20, 20, true, true, true);
	private SequenciaExpressaoDB tmpSequenciaExpr;
	private boolean movingMaoD = false;
	private boolean movingMaoE = false;
	private boolean trocandoPosMaos = false;
	private boolean trocandoSobrancelha = false;
	private boolean trocandoExpressao = false;
	private boolean trocandoSequencia = false;
	private boolean trocandoAvatar = false;
	private boolean recording = false;
	private boolean corrigindo = false;
	private boolean comportamentoAleatorio = false;
	private boolean trocandoSequenciaTemporaria = false;
	private int tempoSequenciaTempDest = 0;
	private int tempoTrocaSequenciaTemp = 0;
	private int tempoComportamentoAleatorio = 0;
	private int tempoDisparaComportamentoAleatorio = 3000; // 3segundos
	private int nivelComportamentoAleatorio = 0;
	//private boolean disparaComportamentoAleatorio = false;
	private ArrayList<Integer[]> listPosRecordingD = new ArrayList<Integer[]>(0);
	private ArrayList<Integer[]> listPosRecordingE = new ArrayList<Integer[]>(0);
	private LinkedList<ExpressaoDB> listExpressaoPendente = new LinkedList<ExpressaoDB>();

	class SequenciaExpressaoPendente {
		public SequenciaExpressaoDB sequenciaExpr;
		public int frameInicio;
		public int tempoParaIniciar;
		
		public SequenciaExpressaoPendente(SequenciaExpressaoDB seq, int frameIni, int tempoIni) {
			sequenciaExpr = seq;
			frameInicio = frameIni;
			tempoParaIniciar = tempoIni;
		}
	}
	
	private LinkedList<SequenciaExpressaoPendente> listSequenciaExpressaoDBPendente = new LinkedList<SequenciaExpressaoPendente>();
	private SequenciaExpressaoDB sequenciaExpressaoAtual;
	private SequenciaExpressaoDB sequenciaExpressaoTemp;
	private int contNumSeqExpressao = 0;
	private float tempoProximaSequenciaExpressao = 0;
	private float tempoContSequenciaExpressao = 0;

	private int numMsg = 0;
	private boolean riscar = false;
	private boolean gameCarregado = false;
	private boolean backgroundCarregado = false;
	private int width = 600;
	private int height = 300;
	private boolean visible;

	class AvatarPendente {
		private Avatar avatar;
		private boolean update;

		public AvatarPendente(Avatar avat, boolean updt) {
			avatar = avat;
			update = updt;
		}

		public Avatar getAvatar() {
			return avatar;
		}

		public boolean getUpdate() {
			return update;
		}
	};

	private LinkedList<AvatarPendente> listSetAvatarPendente = new LinkedList<AvatarPendente>();

	class MovimentoMaoPendente {
		private int mao; // 1 - Esquerda, 2 - Direita
		private int x1;
		private int y1;
		private float anguloFinal;
		private int velocidade;
		private boolean riscar;

		public MovimentoMaoPendente(int maoAtual, int x, int y, float ang, int veloc, boolean risc) {
			this.mao = maoAtual;
			this.x1 = x;
			this.y1 = y;
			this.anguloFinal = ang;
			this.velocidade = veloc;
			this.riscar = risc;
		}

		public int getMao() {
			return mao;
		}

		public int getX1() {
			return x1;
		}

		public int getY1() {
			return y1;
		}

		public float getAnguloFinal() {
			return anguloFinal;
		}

		public int getVelocidade() {
			return velocidade;
		}

		public boolean getRiscar() {
			return riscar;
		}
	}

	class ErrMAO {
		public int err = 0;
		public int cont = 0;
		public int dx = 0;
		public int dy = 0;
		public int sx = 0;
		public int sy = 0;
		public int numSteps = 0;
		public float dAng = 0f;
		public int sAng = 0;
		public int veloc = 0;
	};
	private ErrMAO errMaoD;
	private MovimentoMaoPendente movMaoDPendenteAtual;
	private LinkedList<MovimentoMaoPendente> listMovimentoMaoDPendente = new LinkedList<MovimentoMaoPendente>();

	private ErrMAO errMaoE;
	private MovimentoMaoPendente movMaoEPendenteAtual;
	private LinkedList<MovimentoMaoPendente> listMovimentoMaoEPendente = new LinkedList<MovimentoMaoPendente>();

	class ClassTrocaPosMaos {
		public PosicaoMaosDB pM;
		public int velocidadeMovimentoD;
		public int velocidadeMovimentoE;
		public boolean riscarD;
		public boolean riscarE;
		
		public ClassTrocaPosMaos(PosicaoMaosDB posM, int velocD, int velocE, boolean riscD, boolean riscE) {
			pM = posM;
			velocidadeMovimentoD = velocD;
			velocidadeMovimentoE = velocE;
			riscarD = riscD;
			riscarE = riscE;
		}
	}

	private LinkedList<ClassTrocaPosMaos> listTrocaPosMaosPendente = new LinkedList<ClassTrocaPosMaos>();

	protected final ScreenStack _screens = new ScreenStack() {
		@Override protected void handleError (RuntimeException error) {
			PlayN.log().warn("Screen failure", error);
		}
		@Override protected Transition defaultPushTransition () {
			return slide();
		}
		@Override protected Transition defaultPopTransition () {
			return slide().right();
		}
	};

	protected final ScreenStack _screensTrocaAvatar = new ScreenStack() {
		@Override protected void handleError (RuntimeException error) {
			PlayN.log().warn("Screen failure", error);
		}
		@Override protected Transition defaultPushTransition () {
			return slide();
		}
		@Override protected Transition defaultPopTransition () {
			return slide().right();
		}
	};

	public static enum PosicaoMaos {
		DUAS_MAOS_APONTANDO_ABAIXO(0, 1, 1, 235, 238, 164, 239, 220, 160, 160, 140, 0, 0),
		DUAS_MAOS_NA_CABECA(1, 1, 1, 247, 23, 144, 25, 330, 120, 70, 110, -1f, 0.9f),
		DUAS_MAOS_APONTANDO_ACIMA(2, 1, 1, 200, 6, 196, 6, 280, 130, 110, 120, 0, 0),
		DUAS_MAOS_APONTANDO_DIREITA(3, 5, 5, 407, 89, 327, 160, 290, 130, 130, 190, 0, -0.5f),
		DUAS_MAOS_APONTANDO_ESQUERDA(4, 5, 5, 116, 127, 38, 108, 290, 130, 130, 190, -0.1f, -0.5f),
		BANANA(5, 1, 1, 230, 21, 322, 87, 290, 130, 170, 90, 0, 0),
		POSTCHAU_1(6, 4, 9, 301, 9, 140, 188, 330, 120, 130, 170, 0, 0),
		POSTCHAU_2(7, 4, 9, 262, 4, 140, 188, 330, 120, 130, 170, 0, 0),
		DANCA_1(8, 3, 2, 403, 115, 56, 12, 300, 130, 130, 130, 0, 0),
		DANCA_2(9, 3, 2, 393, 162, 63, 66, 300, 130, 70, 160, 0, 0),
		DANCA_3(10, 3, 5, 346, 129, 94, 18, 300, 130, 70, 160, 0, 0),
		DANCA_X1(11, 1, 1, 249, 196, 184, 207, 220, 160, 160, 140, 0, 0),
		DANCA_X2(12, 9, 1, 248, 176, 195, 174, 230, 130, 160, 140, 0, 0),
		DANCA_X3(13, 9, 1, 193, 197, 120, 190, 230, 130, 160, 140, 0, 0);

		public static PosicaoMaos getPosicaoMaosPerId(int id) {
			PosicaoMaos result = null;
			for (int i = 0; i < PosicaoMaos.values().length; i++) {
				if (PosicaoMaos.values()[i].getId() == id) {
					result = PosicaoMaos.values()[i];
					break;
				}
			}
			return result;
		}

		private PosicaoMaos(int idPos, int mDId, int mEId, int pMDX, int pMDY, int pMEX, int pMEY, int bzDX, int bzDY, int bzEX, int bzEY, float rotMaoD, float rotMaoE) {
			id = idPos;
			maoDId = mDId;
			maoEId = mEId;
			posMDX = pMDX;
			posMDY = pMDY;
			posMEX = pMEX;
			posMEY = pMEY;
			bezierDX = bzDX;
			bezierDY = bzDY;
			bezierEX = bzEX;
			bezierEY = bzEY;
			rotacaoAdicionalMaoD = rotMaoD;
			rotacaoAdicionalMaoE = rotMaoE;
		}

		public int getId() {
			return id;
		}

		public int getMaoDId() {
			return maoDId;
		}

		public int getMaoEId() {
			return maoEId;
		}

		public int getPosMEX() {
			return posMEX;
		}

		public int getPosMEY() {
			return posMEY;
		}

		public int getPosMDX() {
			return posMDX;
		}

		public int getPosMDY() {
			return posMDY;
		}

		public int getBezierDX() {
			return bezierDX;
		}

		public int getBezierDY() {
			return bezierDY;
		}

		public int getBezierEX() {
			return bezierEX;
		}

		public int getBezierEY() {
			return bezierEY;
		}

		public float getRotacaoAdicionalMaoD() {
			return rotacaoAdicionalMaoD;
		}

		public float getRotacaoAdicionalMaoE() {
			return rotacaoAdicionalMaoE;
		}

		private int id;
		private int maoDId;
		private int maoEId;
		private int posMDX;
		private int posMDY;
		private int posMEX;
		private int posMEY;
		private int bezierDX;
		private int bezierDY;
		private int bezierEX;
		private int bezierEY;
		private float rotacaoAdicionalMaoD;
		private float rotacaoAdicionalMaoE;
	};

	public static enum Expressao {
		EXPRESSAO_1(0, PosicaoMaos.DUAS_MAOS_APONTANDO_ACIMA, PosicaoOlhoBoneco.OLHO_ACIMA, PosicaoBoca.FELIZ, MovimentoSobrancelha.SOBRANCELHA_AMBAS_ACIMA),
		EXPRESSAO_2(1, PosicaoMaos.DUAS_MAOS_APONTANDO_ABAIXO, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.INFELIZ, MovimentoSobrancelha.SOBRANCELHA_AMBAS_ABAIXO),
		EXPRESSAO_3(2, PosicaoMaos.DUAS_MAOS_APONTANDO_DIREITA, PosicaoOlhoBoneco.OLHO_LADO_DIREITO, PosicaoBoca.INSATISFEITO, MovimentoSobrancelha.SOBRANCELHA_DIREITA_ACIMA),
		EXPRESSAO_4(3, PosicaoMaos.DUAS_MAOS_APONTANDO_ESQUERDA, PosicaoOlhoBoneco.OLHO_LADO_ESQUERDO, PosicaoBoca.SATISFEITO, MovimentoSobrancelha.SOBRANCELHA_ESQUERDA_ACIMA),
		EXPRESSAO_5(4, PosicaoMaos.BANANA, PosicaoOlhoBoneco.OLHO_DIAGONAL_SUP_DIREITA, PosicaoBoca.SURPRESO, MovimentoSobrancelha.SOBRANCELHA_ROTACAO_BRAVO_AMBAS),
		EXPRESSAO_6(5, PosicaoMaos.DUAS_MAOS_NA_CABECA, PosicaoOlhoBoneco.OLHO_ACIMA, PosicaoBoca.ANGUSTIADO, MovimentoSobrancelha.SOBRANCELHA_ROTACAO_BONZINHO_AMBAS),
		EXPR_TCHAU_1(6, PosicaoMaos.POSTCHAU_1, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.INFELIZ, MovimentoSobrancelha.SOBRANCELHA_PARADA),
		EXPR_TCHAU_2(7, PosicaoMaos.POSTCHAU_2, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.FELIZ, MovimentoSobrancelha.SOBRANCELHA_PARADA),
		EXPR_DANCA_1(8, PosicaoMaos.DANCA_1, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.SATISFEITO, MovimentoSobrancelha.SOBRANCELHA_PARADA),
		EXPR_DANCA_2(9, PosicaoMaos.DANCA_2, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.SURPRESO, MovimentoSobrancelha.SOBRANCELHA_PARADA),
		EXPR_DANCA_3(10, PosicaoMaos.DANCA_3, PosicaoOlhoBoneco.OLHO_ACIMA, PosicaoBoca.FELIZ, MovimentoSobrancelha.SOBRANCELHA_AMBAS_ACIMA),
		EXPR_DANCA_X1(11, PosicaoMaos.DANCA_X1, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.ANGUSTIADO, MovimentoSobrancelha.SOBRANCELHA_PARADA),
		EXPR_DANCA_X2(12, PosicaoMaos.DANCA_X2, PosicaoOlhoBoneco.OLHO_ABAIXO, PosicaoBoca.SATISFEITO, MovimentoSobrancelha.SOBRANCELHA_AMBAS_ABAIXO),
		EXPR_DANCA_X3(13, PosicaoMaos.DANCA_X3, PosicaoOlhoBoneco.OLHO_LADO_ESQUERDO, PosicaoBoca.FELIZ, MovimentoSobrancelha.SOBRANCELHA_PARADA);

		public static Expressao getExpressaoPerId(int id) {
			Expressao result = null;
			for (int i = 0; i < Expressao.values().length; i++) {
				if (Expressao.values()[i].getId() == id) {
					result = Expressao.values()[i];
					break;
				}
			}
			return result;
		}

		private Expressao(int idEx, PosicaoMaos pMaos, PosicaoOlhoBoneco pOlho, PosicaoBoca posBoc, MovimentoSobrancelha sobra) {
			id = idEx;
			posMaos = pMaos;
			posOlho = pOlho;
			posBoca = posBoc;
			sobrancelha = sobra;
		}

		public int getId() {
			return id;
		}

		public PosicaoMaos getPosicaoMaos() {
			return posMaos;
		}

		public PosicaoOlhoBoneco getPosicaoOlhoBoneco() {
			return posOlho;
		}

		public PosicaoBoca getPosicaoBoca() {
			return posBoca;
		}

		public MovimentoSobrancelha getMovimentoSobrancelha() {
			return sobrancelha;
		}

		private int id;
		private PosicaoMaos posMaos;
		private PosicaoOlhoBoneco posOlho;
		private PosicaoBoca posBoca;
		private MovimentoSobrancelha sobrancelha;
	};

	public static enum SequenciaExpressao {
		TCHAUZINHO(0, Expressao.EXPR_TCHAU_1, Expressao.EXPR_TCHAU_2, Expressao.EXPR_TCHAU_1, 700, 200),
		DANCINHA_1(1, Expressao.EXPR_DANCA_1, Expressao.EXPR_DANCA_2, Expressao.EXPR_DANCA_3, 1000, 200),
		DANCINHA_2(2, Expressao.EXPR_DANCA_X1, Expressao.EXPR_DANCA_X2, Expressao.EXPR_DANCA_X3, 1000, 300);

		public static SequenciaExpressao getExpressaoPerId(int id) {
			SequenciaExpressao result = null;
			for (int i = 0; i < SequenciaExpressao.values().length; i++) {
				if (SequenciaExpressao.values()[i].getId() == id) {
					result = SequenciaExpressao.values()[i];
					break;
				}
			}
			return result;
		}

		private SequenciaExpressao(int idEx, Expressao exprIni, Expressao exprIntermed, Expressao exprFim, int tempo1, int tempo2) {
			id = idEx;
			exprInicial = exprIni;
			exprIntermediaria = exprIntermed;
			exprFinal = exprFim;
			tempoLoop1 = tempo1;
			tempoLoop2 = tempo2;
		}

		public int getId() {
			return id;
		}

		public Expressao getExprInicial() {
			return exprInicial;
		}

		public Expressao getExprIntermediaria() {
			return exprIntermediaria;
		}

		public Expressao getExprFinal() {
			return exprFinal;
		}

		public int getTempoLoop1() {
			return tempoLoop1;
		}

		public int getTempoLoop2() {
			return tempoLoop2;
		}

		private int id;
		private Expressao exprInicial;
		private Expressao exprIntermediaria;
		private Expressao exprFinal;
		private int tempoLoop1;
		private int tempoLoop2;
	};

	public static native void alert(String msg) /*-{
		$wnd.alert(msg);
	}-*/;

	public static native void exportaSetBezierD(TestePlayN gameInstance) /*-{
		$wnd.setBezierD = function (x, y) {
		//$wnd.alert("teste inside exportaTesteMsg[" + materia + "][" + cor + "]");
		//$wnd.alert("teste inside exportaTesteMsg ...");
			gameInstance.@qualomelhor.game.TestePlayN::setBezierD(II)(x, y);
		}
	}-*/;

	public static native void exportaSetBezierE(TestePlayN gameInstance) /*-{
		$wnd.setBezierE = function (x, y) {
		//$wnd.alert("teste inside exportaTesteMsg[" + materia + "][" + cor + "]");
		//$wnd.alert("teste inside exportaTesteMsg ...");
			gameInstance.@qualomelhor.game.TestePlayN::setBezierE(II)(x, y);
		}
	}-*/;

	public static native void exportaSetRotacaoMaoD(TestePlayN gameInstance) /*-{
		$wnd.setRotacaoAdicionalD = function (ang) {
		//$wnd.alert("teste inside exportaTesteMsg[" + materia + "][" + cor + "]");
		//$wnd.alert("teste inside exportaTesteMsg ...");
			gameInstance.@qualomelhor.game.TestePlayN::setRotacaoMaoD(FZ)(ang, true);
		}
	}-*/;

	public static native void exportaSetRotacaoMaoE(TestePlayN gameInstance) /*-{
		$wnd.setRotacaoAdicionalE = function (ang) {
			gameInstance.@qualomelhor.game.TestePlayN::setRotacaoMaoE(FZ)(ang, true);
		}
	}-*/;

	//public static native void exportaMoveMaoD(TestePlayN gameInstance) /*-{		
	//	$wnd.moveMaoD = function (x, y, ang) {
	//		gameInstance.@qualomelhor.game.TestePlayN::moveMaoD_New(IIFZ)(x, y, ang, true);
	//	}
	//}-*/;

	//public static native void exportaStartMoveMaoD(TestePlayN gameInstance) /*-{		
	//	$wnd.startMoveMaoD = function (x, y, velocD, velocE, ang) {
	//		gameInstance.@qualomelhor.game.TestePlayN::startMovimentoMaoD(IIFIZ)(x, y, velocD, velocE, ang, true);
	//	}
	//}-*/;

	public static native void exportaSetEstiloMao(TestePlayN gameInstance) /*-{
		$wnd.setEstiloMao_j = function (estiloMao) {
			gameInstance.@qualomelhor.game.TestePlayN::setEstiloMao(IZ)(estiloMao, true);
		}
	}-*/;

	public static native void exportaSetSubMaoD(TestePlayN gameInstance) /*-{		
		$wnd.setSubMaoD_j = function (subMao) {
			gameInstance.@qualomelhor.game.TestePlayN::setSubMaoD(IZ)(subMao, true);
		}
	}-*/;

	public static native void exportaSetSubMaoE(TestePlayN gameInstance) /*-{
		$wnd.setSubMaoE_j = function (subMao) {
			gameInstance.@qualomelhor.game.TestePlayN::setSubMaoE(IZ)(subMao, true);
		}
	}-*/;

	//public static native void exportaAddTempSequenciaExpressao(TestePlayN gameInstance) /*-{
	//	$wnd.addTmpSeqExpr_j = function (tempo, velocD, velocE) {
	//		gameInstance.@qualomelhor.game.TestePlayN::addTmpSequenciaExpr(III)(tempo, velocD, velocE);
	//	}
	//}-*/;

	public static native void exportaAddSequenciaExpressao(TestePlayN gameInstance) /*-{
		$wnd.addSeqExpr_j = function (nome, tempo, animar) {
			gameInstance.@qualomelhor.game.TestePlayN::addSequenciaExpr(Ljava/lang/String;IZ)(nome, tempo, animar);
		}
	}-*/;

	public static native void exportaRemoveTempSequenciaExpressao(TestePlayN gameInstance) /*-{
		$wnd.removeTmpSeqExpr_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::removeTmpSequenciaExpr()();
		}
	}-*/;

	public static native void exportaPlayTempSequenciaExpressao(TestePlayN gameInstance) /*-{
		$wnd.playTmpSeqExpr_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::playTmpSequenciaExpr()();
		}
	}-*/;

	//public static native void exportaSalvaTempSequenciaExpressao(TestePlayN gameInstance) /*-{
	//	$wnd.salvaTmpSeqExpr_j = function (nome, velocD, velocE, riscar, animar) {
	//		gameInstance.@qualomelhor.game.TestePlayN::salvaExpressaoAtual(Ljava/lang/String;IIZZ)(nome, velocD, velocE, riscar, animar);
	//	}
	//}-*/;

	public static native void exportaTrocaPosicaoMaos(TestePlayN gameInstance) /*-{
		$wnd.trocaMaos = function (mao) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaPosicaoMaos(I)(mao);
		}
	}-*/;

	public static native void exportaTrocaPosicaoBoca(TestePlayN gameInstance) /*-{
		$wnd.trocaPosicaoBoca_j = function (posBocaId) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaPosicaoBoca(I)(posBocaId);
		}
	}-*/;

	public static native void exportaTrocaEstiloBoca(TestePlayN gameInstance) /*-{
		$wnd.trocaEstiloBoca_j = function (estiloBoca) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaEstiloBoca(I)(estiloBoca);
		}
	}-*/;

	public static native void exportaTrocaPosicaoOlho(TestePlayN gameInstance) /*-{
		$wnd.trocaPosicaoOlho_j = function (posOlho) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaPosicaoOlho(I)(posOlho);
		}
	}-*/;

	public static native void exportaTrocaEstiloOlho(TestePlayN gameInstance) /*-{
		$wnd.trocaEstiloOlho_j = function (estiloOlho) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaEstiloOlho(I)(estiloOlho);
		}
	}-*/;

	public static native void exportaTrocaMovimentoSobrancelha(TestePlayN gameInstance) /*-{
		$wnd.trocaMovimentoSobrancelha_j = function (sobrancelha) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaMovimentoSobrancelha(I)(sobrancelha);
		}
	}-*/;

	public static native void exportaTrocaEstiloSobrancelha(TestePlayN gameInstance) /*-{
		$wnd.trocaEstiloSobrancelha_j = function (sobrancelha) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaEstiloSobrancelha(I)(sobrancelha);
		}
	}-*/;

	public static native void exportaTrocaSequenciaExpressao(TestePlayN gameInstance) /*-{
		$wnd.trocaSequenciaExpressao = function (sequenciaExpressao) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaSequencia(I)(sequenciaExpressao);
		}
	}-*/;

	public static native void exportaSalvaPosicaoMaoDB(TestePlayN gameInstance) /*-{
		$wnd.salvaPosicaoMao_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::salvaPosicaoMaoAtual(Ljava/lang/String;)(nome);
		}
	}-*/;

	public static native void exportaSalvaExpressaoDB(TestePlayN gameInstance) /*-{
		$wnd.salvaExpressao_j = function (nome, posOlhoId, posBocaId, movSobrancelhaId, subMaoDId, subMaoEId, pMDX, pMDY, pMEX, pMEY, bDBezierX, bDBezierY, bEBezierX, bEBezierY, rotAdicionalMD, rotAdicionalME, velocD, velocE, riscarD, riscarE, animar) {
			gameInstance.@qualomelhor.game.TestePlayN::salvaExpressaoDB(Ljava/lang/String;IIIIIIIIIIIIIFFIIZZZ)(nome, posOlhoId, posBocaId, movSobrancelhaId, subMaoDId, subMaoEId, pMDX, pMDY, pMEX, pMEY, bDBezierX, bDBezierY, bEBezierX, bEBezierY, rotAdicionalMD, rotAdicionalME, velocD, velocE, riscarD, riscarE, animar);
		}
	}-*/;

	public static native void exportaAlteraExpressaoTmp(TestePlayN gameInstance) /*-{
		$wnd.alteraExpressaoTmp_j = function (mao, indice, maoId, subMaoId, sobrancelhaId, estiloOlhoId, posicaoOlhoId, estiloBocaId, posBocaId, rotacao, bezierX, bezierY, veloc, riscar) {
			gameInstance.@qualomelhor.game.TestePlayN::alteraExpressaoTmp(IIIIIIIIIFIIIZ)(mao, indice, maoId, subMaoId, sobrancelhaId, estiloOlhoId, posicaoOlhoId, estiloBocaId, posBocaId, rotacao, bezierX, bezierY, veloc, riscar);
		}
	}-*/;

	public static native void exportaSalvaSequenciaExpressaoDB(TestePlayN gameInstance) /*-{
		$wnd.salvaSequenciaExpressao_j = function (nome, restart, tempoRestart, frameRestart) {
			gameInstance.@qualomelhor.game.TestePlayN::salvaSequenciaExpressaoAtual(Ljava/lang/String;ZII)(nome, restart, tempoRestart, frameRestart);
		}
	}-*/;

	public static native void carregaFormDadosSequencia(String nomeSequencia, boolean restart, int tempoRestart, int frameRestart) /*-{
		$wnd.carregaFormDadosSequencia_js(nomeSequencia, restart, tempoRestart, frameRestart);
	}-*/;

	public static native void exportaDeletaPosicaoMaoDB(TestePlayN gameInstance) /*-{
		$wnd.deletaPosicaoMao_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::deletaPosicaoMaoDB(Ljava/lang/String;)(nome);
		}
	}-*/;

	public static native void exportaDeletaTodasExpressoesDB(TestePlayN gameInstance) /*-{
		$wnd.deletaTodasExpressoes_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::deletaTodasExpressoesDB()();
		}
	}-*/;

	public static native void exportaDeletaTodasPosicoesMaosDB(TestePlayN gameInstance) /*-{
		$wnd.deletaTodasPosicoesMaos_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::deletaTodasPosicoesMaosDB()();
		}
	}-*/;

	public static native void exportaDeletaExpressaoDB(TestePlayN gameInstance) /*-{
		$wnd.deletaExpressao_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::deletaExpressaoDB(Ljava/lang/String;)(nome);
		}
	}-*/;

	public static native void exportaCarregaPosicaoMaoDB(TestePlayN gameInstance) /*-{
		$wnd.carregaPosicaoMao_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::carregaPosicaoMaoAtual(Ljava/lang/String;IIZZ)(nome, 2, 2, true, true);
		}
	}-*/;

	public static native void exportaCarregaExpressaoDB(TestePlayN gameInstance) /*-{
		$wnd.carregaExpressao_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::carregaExpressaoDB(Ljava/lang/String;Z)(nome, true);
		}
	}-*/;

	public static native void exportaCarregaSequenciaExpressaoDB(TestePlayN gameInstance) /*-{
		$wnd.carregaSequenciaExpressao_j = function (nome, atualizar) {
			gameInstance.@qualomelhor.game.TestePlayN::carregaSequenciaExpressaoAtual(Ljava/lang/String;IZ)(nome, 0, atualizar);
		}
	}-*/;

	public static native void exportaEditarSequenciaExpressaoDB(TestePlayN gameInstance) /*-{
		$wnd.editarSequenciaExpressao_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::carregaSequenciaExpressaoAtual(Ljava/lang/String;IZ)(nome, 1, true);
		}
	}-*/;

	public static native void exportaEditarSequenciaTmp(TestePlayN gameInstance) /*-{
		$wnd.editarSequenciaTemp_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::editarSequenciaTemp()();
		}
	}-*/;

	public static native void exportaTrocaExpressao(TestePlayN gameInstance) /*-{
		$wnd.trocaExpressao = function (expressao) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaExpressao(I)(expressao);
		}
	}-*/;

	public static native void exportaMaoAtualMouse(TestePlayN gameInstance) /*-{
		$wnd.setMaoAtualMouse = function (mao) {
		//$wnd.alert("teste inside exportaTesteMsg[" + materia + "][" + cor + "]");
			//$wnd.alert("teste mao = " + mao);
			gameInstance.@qualomelhor.game.TestePlayN::setMouseMaoAtual(I)(mao);
		}
	}-*/;

	public static native void exportaSetPosicaoBoneco(TestePlayN gameInstance) /*-{
		$wnd.setPosicaoBoneco_j = function (x, y) {
			gameInstance.@qualomelhor.game.TestePlayN::setPosicaoBoneco(II)(x, y);
		}
	}-*/;

	public static native void exportaSetSize(TestePlayN gameInstance) /*-{
		$wnd.setSize_j = function (w, h) {
			gameInstance.@qualomelhor.game.TestePlayN::setSize(II)(w, h);
		}
	}-*/;

	public static native void exportaAddPosicaoBoneco(TestePlayN gameInstance) /*-{
		$wnd.addPosicaoBoneco_j = function (x, y) {
			gameInstance.@qualomelhor.game.TestePlayN::addPosicaoBoneco(II)(x, y);
		}
	}-*/;

	public static native void exportaRecording(TestePlayN gameInstance) /*-{
		$wnd.setRecording_j = function (reestart) {
			gameInstance.@qualomelhor.game.TestePlayN::setRecording(ZZ)(true, reestart);
		}
	}-*/;

	public static native void exportaSetRiscar(TestePlayN gameInstance) /*-{
		$wnd.setRiscar_j = function (riscar) {
			gameInstance.@qualomelhor.game.TestePlayN::setRisca(Z)(riscar);
		}
	}-*/;

	public static native void exportaSetBackgroundAndMove(TestePlayN gameInstance) /*-{
		$wnd.setBackgroundAndMove_j = function (imageUrl, xMov, yMov) {
			gameInstance.@qualomelhor.game.TestePlayN::setBackgroundAndMove(Ljava/lang/String;II)(imageUrl, xMov, yMov);
		}
	}-*/;

	public static native void exportaScaleBackground(TestePlayN gameInstance) /*-{
		$wnd.setBackgroundScale_j = function (scaleX, scaleY) {
			gameInstance.@qualomelhor.game.TestePlayN::scaleBackground(FF)(scaleX, scaleY);
		}
	}-*/;

	public static native void exportaSetBackground(TestePlayN gameInstance) /*-{
		$wnd.setBackground_j = function (imageUrl) {
			gameInstance.@qualomelhor.game.TestePlayN::setBackground(Ljava/lang/String;)(imageUrl);
		}
	}-*/;

	public static native void exportaMoveBackground(TestePlayN gameInstance) /*-{
		$wnd.moveBackground_j = function (x, y) {
			gameInstance.@qualomelhor.game.TestePlayN::moveBackground(II)(x, y);
		}
	}-*/;

	public static native void exportaCorrigindo(TestePlayN gameInstance) /*-{
		$wnd.setCorrigindo_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::setCorrigindo(Z)(true);
		}
	}-*/;

	public static native void exportaGravaExpressaoRecording(TestePlayN gameInstance) /*-{
		$wnd.gravaExpressaoRecording_j = function (nome) {
			gameInstance.@qualomelhor.game.TestePlayN::gravaExpressaoRecording(Ljava/lang/String;)(nome);
		}
	}-*/;

	public static native void exportaSendMsgText(TestePlayN gameInstance) /*-{
		$wnd.sendMsgText_j = function (txt) {
			gameInstance.@qualomelhor.game.TestePlayN::sendMsgText(Ljava/lang/String;)(txt);
		}
	}-*/;

	public static native void exportaSendMsgText2(TestePlayN gameInstance) /*-{
		$wnd.sendMsgText2_j = function (txt, hideOnTime) {
			gameInstance.@qualomelhor.game.TestePlayN::sendMsgText(Ljava/lang/String;Z)(txt, hideOnTime);
		}
	}-*/;

	public static native void exportaVerificaGameCarregado(TestePlayN gameInstance) /*-{
		$wnd.verificaGameCarregado_j = function () {
			return gameInstance.@qualomelhor.game.TestePlayN::verificaGameCarregado()();
		}
	}-*/;

	public static native void exportaSetVisible(TestePlayN gameInstance) /*-{
		$wnd.setVisible_j = function (visible) {
			return gameInstance.@qualomelhor.game.TestePlayN::setVisible(Z)(visible);
		}
	}-*/;

	public static native void exportaVerificaBackgroundCarregado(TestePlayN gameInstance) /*-{
		$wnd.verificaBackgroundCarregado_j = function () {
			return gameInstance.@qualomelhor.game.TestePlayN::verificaBackgroundCarregado()();
		}
	}-*/;

	public static native void exportaGetStringAvatar(TestePlayN gameInstance) /*-{
		$wnd.getStringAvatar_j = function () {
			return gameInstance.@qualomelhor.game.TestePlayN::getStringAvatar()();
		}
	}-*/;

	public static native void exportaIniciaComportamentoAleatorio(TestePlayN gameInstance) /*-{
		$wnd.iniciaComportamentoAleatorio_j = function (tempo, nivel) {
			gameInstance.@qualomelhor.game.TestePlayN::iniciaComportamentoAleatorio(II)(tempo, nivel);
		}
	}-*/;

	public static native void exportaTrocaAvatarAleatorio(TestePlayN gameInstance) /*-{
		$wnd.trocaAvatarAleatorio_j = function (update) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaAvatarAleatorio(Z)(update);
		}
	}-*/;

	public static native void exportaTrocaProximaParteAvatar(TestePlayN gameInstance) /*-{
		$wnd.trocaProximaParteAvatar_j = function (parte) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaProximaParteAvatar(Ljava/lang/String;)(parte);
		}
	}-*/;

	public static native void exportaTrocaParteAvatarAleatorio(TestePlayN gameInstance) /*-{
		$wnd.trocaParteAvatarAleatorio_j = function (parte) {
			gameInstance.@qualomelhor.game.TestePlayN::trocaParteAvatarAleatorio(Ljava/lang/String;)(parte);
		}
	}-*/;

	public static native void exportaSetAvatar(TestePlayN gameInstance) /*-{
		$wnd.setAvatar_j = function (strAv, update) {
			gameInstance.@qualomelhor.game.TestePlayN::setAvatar(Ljava/lang/String;Z)(strAv, update);
		}
	}-*/;

	public static native void exportaSetButtonsTrocaVisible(TestePlayN gameInstance) /*-{
		$wnd.setButtonsTrocaVisible_j = function (visible) {
			gameInstance.@qualomelhor.game.TestePlayN::setButtonsTrocaAvatarVisible(Z)(visible);
		}
	}-*/;

	public static native void exportaHabilitaMouseClicks(TestePlayN gameInstance) /*-{
		$wnd.habilitaMouseClicks_j = function () {
			gameInstance.@qualomelhor.game.TestePlayN::habilitaMouseClicks()();
		}
	}-*/;

	public static native void setMessageBox(String msg) /*-{
		//$wnd.alert("alerting..." + msg);
		if ($wnd.messageBox) {
			$wnd.messageBox(msg);
		}
	}-*/;

	public static native void carregaFormAET(int mao, int indice, int estiloMaoId, int subMaoId, int sobrancelhaId, int olhoId, int bocaId, float rotacao, int bezierX, int bezierY, int veloc, boolean riscar) /*-{
		$wnd.carregaFormAET(mao, indice, estiloMaoId, subMaoId, sobrancelhaId, olhoId, bocaId, rotacao, bezierX, bezierY, veloc, riscar);
		$wnd.messageBox("carregou o form aet");
	}-*/;

	public static native void setVariavelCarregamento(int valor) /*-{
		$wnd.variavelCarregamento = valor;
		//$wnd.messageBox("setou a variavel carregamento: " + valor + "!!!!!!!!!");
	}-*/;

	public static native void setPosD(int pX, int pY) /*-{
		$wnd.setPosD(pX, pY);
	}-*/;

	public static native void setPosE(int pX, int pY) /*-{
		$wnd.setPosE(pX, pY);
	}-*/;

	public static native void setBzD(int bzX, int bzY) /*-{
		//$wnd.alert("setBezierDClient = " + $wnd.setBezierDClient);
		$wnd.setBezierDClient(bzX, bzY);
		//$wnd.alert("(bezierD x, y) = (" + bzX + ", " + bzY + ")");
	}-*/;

	public static native void setBzE(int bzX, int bzY) /*-{
		//$wnd.alert("setBezierEClient = " + $wnd.setBezierEClient);  
		$wnd.setBezierEClient(bzX, bzY);
		//$wnd.alert("(bezierE x, y) = (" + bzX + ", " + bzY + ")");
	}-*/;

	@Override
	public void init() {
		PlayN.graphics().setSize(600, 300);
	}

	public TestePlayN() {

		setMessageBox("Iniciando game...");

		exportaSetBezierD(this);
		exportaSetBezierE(this);
		exportaSetEstiloMao(this);
		exportaSetSubMaoD(this);
		exportaSetSubMaoE(this);
		exportaSetRotacaoMaoD(this);
		exportaSetRotacaoMaoE(this);
		exportaTrocaPosicaoMaos(this);
		exportaTrocaExpressao(this);
		exportaMaoAtualMouse(this);
		exportaTrocaSequenciaExpressao(this);
		//exportaMoveMaoD(this);
		//exportaStartMoveMaoD(this);
		exportaSalvaPosicaoMaoDB(this);
		exportaCarregaPosicaoMaoDB(this);
		exportaDeletaPosicaoMaoDB(this);
		exportaSalvaExpressaoDB(this);
		exportaCarregaExpressaoDB(this);
		exportaDeletaExpressaoDB(this);
		exportaTrocaPosicaoBoca(this);
		exportaTrocaEstiloBoca(this);
		exportaTrocaMovimentoSobrancelha(this);
		exportaTrocaEstiloSobrancelha(this);
		exportaTrocaPosicaoOlho(this);
		exportaTrocaEstiloOlho(this);
		exportaCarregaSequenciaExpressaoDB(this);
		//exportaAddTempSequenciaExpressao(this);
		exportaAddSequenciaExpressao(this);
		exportaRemoveTempSequenciaExpressao(this);
		exportaPlayTempSequenciaExpressao(this);
		//exportaSalvaTempSequenciaExpressao(this);
		exportaRecording(this);
		exportaGravaExpressaoRecording(this);
		exportaSalvaSequenciaExpressaoDB(this);
		exportaDeletaTodasExpressoesDB(this);
		exportaDeletaTodasPosicoesMaosDB(this);
		exportaCorrigindo(this);
		exportaSetRiscar(this);
		exportaEditarSequenciaExpressaoDB(this);
		exportaAlteraExpressaoTmp(this);
		exportaEditarSequenciaTmp(this);
		exportaSendMsgText(this);
		exportaSendMsgText2(this);
		exportaIniciaComportamentoAleatorio(this);
		exportaVerificaGameCarregado(this);
		exportaSetBackground(this);
		exportaSetBackgroundAndMove(this);
		exportaSetPosicaoBoneco(this);
		exportaAddPosicaoBoneco(this);
		exportaVerificaBackgroundCarregado(this);
		exportaSetVisible(this);
		exportaSetSize(this);
		exportaTrocaAvatarAleatorio(this);
		exportaTrocaProximaParteAvatar(this);
		exportaGetStringAvatar(this);
		exportaTrocaParteAvatarAleatorio(this);
		exportaSetAvatar(this);
		exportaHabilitaMouseClicks(this);
		exportaMoveBackground(this);
		exportaScaleBackground(this);
		exportaSetButtonsTrocaVisible(this);

		//trocaAvatarAleatorio();
	    setImage();

	    gameCarregado = true;
	}

	private void habilitaMouseClicks() {
	    PlayN.pointer().setListener(new Pointer.Adapter() {

	    	@Override
	    	public void onPointerDrag(Pointer.Event event) {
	    		//int x = (int)event.x();
	    		//int y = (int)event.y();
	    	}

	    	@Override
	    	public void onPointerEnd(Pointer.Event event) {

	    		//************Pea test****************
	    		/*
	    		Pea p = new Pea(peaLayer, event.x(), event.y());
	    		peas.add(p);

	    		PeaPhy peaPhy = new PeaPhy(myWorld, myWorld.world, physUnitPerScreenUnit * event.x(), physUnitPerScreenUnit * event.y(), 0);
	    		myWorld.add(peaPhy);
	    		peaPhy.getBody().applyForce(new Vec2(600, 300), peaPhy.getBody().getPosition());
	    		*/
	    		//************************************
	    		//setMessageBox("click...");
	    		
	    		//int i = (int)Math.floor(Random.nextDouble() * PosicaoMaos.values().length);
	    		//trocaCaraAleatoria();

	    		/*
	    		drawPoint(canvasImgDraw, (int)event.x(), (int)event.y(), Color.rgb(100, 50, 100));
	    		imgDraw.setImage(canvasImgDraw);
	    		*/	    

    			final int px = (int)event.x();
    			final int py = (int)event.y();

	    		if (recording) {
	    			//posiciona e desenha o ponto, armazena o ponto para salvar depois
	    			if (maoAtualMouse == 1) {
	    				colocaPontoTmpExpressao(maoAtualMouse, px, py, maoD.getSubMaoId(), sobrancelhas.getMovimentoSobrancelhaAtual().getId(), olhos.getPosicaoOlhoAtual().getId(), boca.getPosicaoBocaAtual().getId(), riscar, bracoD.getBezierX(), bracoD.getBezierY(), 2, rotacaoAdicionalMD);
	    			} else {
	    				colocaPontoTmpExpressao(maoAtualMouse, px, py, maoE.getSubMaoId(), sobrancelhas.getMovimentoSobrancelhaAtual().getId(), olhos.getPosicaoOlhoAtual().getId(), boca.getPosicaoBocaAtual().getId(), riscar, bracoE.getBezierX(), bracoE.getBezierY(), 2, rotacaoAdicionalME);
	    			}
	    		} else {
	    			if (!corrigindo) {
		    			if (maoAtualMouse == 1) {
		    				startMovimentoMaoD(px, py, rotacaoAdicionalMD, 2, riscar);
		    				//moveMaoD_New(px, py, rotacaoAdicionalMD, true);
		    			} else {
		    				startMovimentoMaoE(px, py, rotacaoAdicionalME, 2, riscar);
		    				//moveMaoE_New(px, py, rotacaoAdicionalME, true);
		    			}
	    			}
	    		}
	    	}
	    });
	}

	private void setButtonsTrocaAvatarVisible(boolean visible) {
		if (trocaAvatar != null) {
			trocaAvatar.setVisible(visible);
		}
	}

	private boolean verificaGameCarregado() {
		return gameCarregado;
	}

	private boolean verificaBackgroundCarregado() {
		return backgroundCarregado;
	}

	private void iniciaComportamentoAleatorio(int tempoDisparo, int nivelAleatorio) {
		nivelComportamentoAleatorio = nivelAleatorio;
		tempoDisparaComportamentoAleatorio = tempoDisparo;
		comportamentoAleatorio = true;
	}

	private void colocaPontoTmpExpressao(final int maoAtualMouse, final int px, final int py, final int subMaoId, final int sobrancelhaId, final int olhoId, final int posBocaId, final boolean riscar, final int bezierX, final int bezierY, final int veloc, final float rotacao) {

		if (maoAtualMouse == 1) {
    		listPosRecordingD.add(new Integer[]{px, py});
			moveMaoD_New(px, py, rotacao, riscar);
		} else {
			listPosRecordingE.add(new Integer[]{px, py});
			moveMaoE_New(px, py, rotacao, riscar);
		}
		final Image imgE = assets().getImage("/images/pontoesq.png");
		final Image imgD = assets().getImage("/images/pontodir.png");

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens dos pontos...");
			}

			@Override
			public void done() {
				final ImageLayer imgLD = graphics().createImageLayer(imgD);
				final ImageLayer imgLE = graphics().createImageLayer(imgE);

				final ImageLayer imgL = maoAtualMouse == 1?imgLD:imgLE; 
	    		imgL.setOrigin(imgD.width()/2, imgD.height()/2);
				imgL.setTranslation(px, py);
				//int c = (maoAtualMouse == 1?Color.rgb(100, 10, 100):Color.rgb(10, 100, 10));
				//final CanvasImage cnv = drawNumber(px, py, c, (maoAtualMouse == 1?listImgDrawD.size():listImgDrawE.size()));

				//final ImageLayer imgLN = graphics().createImageLayer(cnv);
				final ImageLayer imgLN = getTextBox(String.valueOf(maoAtualMouse == 1?listImgDrawD.size():listImgDrawE.size()));
				imgLN.setTranslation(px+10, py);

				if (lyGrid.size() == 0) {
					lyGrid.add(getGrid());
					setMessageBox("adicionou o grid...");
				}

			    lyDraw.add(imgL);
			    lyDraw.add(imgLN);

			    System.out.println("Adicionou as imagens...");

    			imgL.addListener(new Pointer.Adapter() {
    		    	@Override
    		    	public void onPointerDrag(Pointer.Event event) {
    		    		if (corrigindo) {
    		    			setMessageBox("pegou o item.." + event.x() + ", " + event.y());
    		    			int evtX = (int)event.x(), evtY = (int)event.y();
    		    			imgL.setTranslation(evtX, evtY);
    		    			imgLN.setTranslation(evtX + 8, evtY);
    		    			setMessageBox("Arrastando...");
    		    			
    		    			//atualizar os dados no form AET (altera expressao tmp)
    		    			boolean achou = false;
    		    			setMessageBox("listImgDrawD.size() = " + listImgDrawD.size());
    		    			for (int i = 0; i < listImgDrawD.size(); i++) {
    		    				if (listImgDrawD.get(i).imgL == imgL) {
    		    					carregaFormAET(1, i, avatarAtual.getCodParteMao(), listImgDrawD.get(i).exprDB.getPosicaoMaos().getSubMaoDId(), listImgDrawD.get(i).exprDB.getMovimentoSobrancelha().getId(), listImgDrawD.get(i).exprDB.getPosicaoOlhoBoneco().getId(), listImgDrawD.get(i).exprDB.getPosicaoBoca().getId(), listImgDrawD.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoD(), listImgDrawD.get(i).exprDB.getPosicaoMaos().getBezierDX(), listImgDrawD.get(i).exprDB.getPosicaoMaos().getBezierDY(), listImgDrawD.get(i).exprDB.getVelocidadeD(), listImgDrawD.get(i).exprDB.getRiscarD());
    		    					posMDX = evtX;
    		    					posMDY = evtY;
    		    					setRotacaoMaoD(listImgDrawD.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoD(), false);
    		    					//moveMaoD_New(evtX, evtY, listImgDrawD.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoD(), false);
    		    					bracoD.setBezier(listImgDrawD.get(i).exprDB.getPosicaoMaos().getBezierDX(), listImgDrawD.get(i).exprDB.getPosicaoMaos().getBezierDY());
    		    					if (maoD.getSubMaoId() != listImgDrawD.get(i).exprDB.getPosicaoMaos().getSubMaoDId()) {
    		    						setSubMaoD(listImgDrawD.get(i).exprDB.getPosicaoMaos().getSubMaoDId(), true);
    		    					} else {
    		    						moveMaoD_New(evtX, evtY, listImgDrawD.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoD(), false);
    		    					}
    		    					if (boca.getPosicaoBocaAtual() != listImgDrawD.get(i).exprDB.getPosicaoBoca()) {
    		    						boca.trocaPosicaoBoca(listImgDrawD.get(i).exprDB.getPosicaoBoca());	
    		    					}
    		    					if (sobrancelhas.getMovimentoSobrancelhaAtual() != listImgDrawD.get(i).exprDB.getMovimentoSobrancelha()) {
    		    						sobrancelhas.trocaMovimentoSobrancelha(listImgDrawD.get(i).exprDB.getMovimentoSobrancelha());
    		    					}
    		    					if (olhos.getPosicaoOlhoAtual() != listImgDrawD.get(i).exprDB.getPosicaoOlhoBoneco()) {
    		    						olhos.trocaPosicaoOlho(listImgDrawD.get(i).exprDB.getPosicaoOlhoBoneco());
    		    					}
    		    					achou = true;
    		    					break;
    		    				}
    		    			}
    		    			
    		    			if (!achou) {
    		    				for (int i = 0; i < listImgDrawE.size(); i++) {
        		    				if (listImgDrawE.get(i).imgL == imgL) {
        		    					carregaFormAET(2, i, avatarAtual.getCodParteMao(), listImgDrawE.get(i).exprDB.getPosicaoMaos().getSubMaoEId(), listImgDrawE.get(i).exprDB.getMovimentoSobrancelha().getId(), listImgDrawE.get(i).exprDB.getPosicaoOlhoBoneco().getId(), listImgDrawE.get(i).exprDB.getPosicaoBoca().getId(), listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE(), listImgDrawE.get(i).exprDB.getPosicaoMaos().getBezierEX(), listImgDrawE.get(i).exprDB.getPosicaoMaos().getBezierEY(), listImgDrawE.get(i).exprDB.getVelocidadeE(), listImgDrawE.get(i).exprDB.getRiscarE());
        		    					posMEX = evtX;
        		    					posMEY = evtY;
        		    					setRotacaoMaoE(listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE(), false);
        		    					//moveMaoE_New(evtX, evtY, listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE(), false);
        		    					bracoE.setBezier(listImgDrawE.get(i).exprDB.getPosicaoMaos().getBezierEX(), listImgDrawE.get(i).exprDB.getPosicaoMaos().getBezierEY());
        		    					if (maoE.getSubMaoId() != listImgDrawE.get(i).exprDB.getPosicaoMaos().getSubMaoEId()) {
        		    						setSubMaoE(listImgDrawE.get(i).exprDB.getPosicaoMaos().getSubMaoEId(), true);
        		    					} else {
        		    						moveMaoE_New(evtX, evtY, listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE(), false);
        		    					}
        		    					if (boca.getPosicaoBocaAtual() != listImgDrawE.get(i).exprDB.getPosicaoBoca()) {
        		    						boca.trocaPosicaoBoca(listImgDrawE.get(i).exprDB.getPosicaoBoca());
        		    					}
        		    					if (sobrancelhas.getMovimentoSobrancelhaAtual() != listImgDrawE.get(i).exprDB.getMovimentoSobrancelha()) {
        		    						sobrancelhas.trocaMovimentoSobrancelha(listImgDrawE.get(i).exprDB.getMovimentoSobrancelha());
        		    					}
        		    					if (olhos.getPosicaoOlhoAtual() != listImgDrawE.get(i).exprDB.getPosicaoOlhoBoneco()) {
        		    						olhos.trocaPosicaoOlho(listImgDrawE.get(i).exprDB.getPosicaoOlhoBoneco());
        		    					}
        		    					break;
        		    				}
        		    			}
    		    			}
    		    		}
    		    	}
    			});

    			ExpressaoDB tmpExpr;
				tmpExpr = expressaoAtual.clone();

	    		if (maoAtualMouse == 1) {
	    			tmpExpr.setRiscarD(riscar);
	    			//tmpExpr.getPosicaoMaos().setMaoId(maoId);
	    			tmpExpr.getPosicaoMaos().setSubMaoDId(subMaoId);
	    			tmpExpr.getPosicaoMaos().setRotacaoAdicionalMaoD(rotacao);
	    			tmpExpr.getPosicaoMaos().setBezierDX(bezierX);
	    			tmpExpr.getPosicaoMaos().setBezierDY(bezierY);
	    			tmpExpr.setVelocidadeD(veloc);
	    			tmpExpr.setPosicaoBoca(PosicaoBoca.getPosicaoBocaPorId(posBocaId));
	    			tmpExpr.setMovimentoSobrancelha(MovimentoSobrancelha.getMovimentoSobrancelhaId(sobrancelhaId));
	    			tmpExpr.setPosicaoOlhoBoneco(PosicaoOlhoBoneco.getPosicaoOlhoPerId(olhoId));
	    			listImgDrawD.add(new ObjImgPosicao(tmpExpr, imgL));

	    			if (listImgDrawD.size() == 1) {
	    				listImgDrawD.get(0).exprDB.setRiscarD(false);
	    			}

	    			setMessageBox("adicionou o ponto. size: " + listImgDrawD.size() + " (px, py) = (" + px + ", " + py + ")");
	    		} else {
	    			tmpExpr.setRiscarE(riscar);
	    			//tmpExpr.getPosicaoMaos().setMaoId(maoId);
	    			tmpExpr.getPosicaoMaos().setSubMaoEId(subMaoId);
	    			tmpExpr.getPosicaoMaos().setBezierEX(bezierX);
	    			tmpExpr.getPosicaoMaos().setBezierEY(bezierY);
	    			tmpExpr.getPosicaoMaos().setRotacaoAdicionalMaoE(rotacao);
	    			tmpExpr.setVelocidadeE(veloc);
	    			tmpExpr.setPosicaoBoca(PosicaoBoca.getPosicaoBocaPorId(posBocaId));
	    			tmpExpr.setMovimentoSobrancelha(MovimentoSobrancelha.getMovimentoSobrancelhaId(sobrancelhaId));
	    			tmpExpr.setPosicaoOlhoBoneco(PosicaoOlhoBoneco.getPosicaoOlhoPerId(olhoId));
	    			listImgDrawE.add(new ObjImgPosicao(tmpExpr, imgL));

	    			if (listImgDrawE.size() == 1) {
	    				listImgDrawE.get(0).exprDB.setRiscarE(false);
	    			}

	    			setMessageBox("adicionou o ponto. size: " + listImgDrawE.size() + " (px, py) = (" + px + ", " + py + ")");
	    		}
			}
		});
		as.add(imgD);
		as.add(imgE);
		as.start();
	}

	private void setMouseMaoAtual(int maoAtual) {
		maoAtualMouse = maoAtual;
	}

	private void setPosicaoBoneco(int x, int y) {
		int xDif = x - xPosBoneco;
		int yDif = y - yPosBoneco;
		addPosicaoBoneco(xDif, yDif);
	}

	private int getWidth() {
		return width;
	}

	private int getHeight() {
		return height;
	}

	private void setSize(int w, int h) {
		width = w;
		height = h;
		PlayN.graphics().setSize(w, h);
	}

	private void addPosicaoBoneco(int x, int y) {
		xPosBoneco += x;
		yPosBoneco += y;
		layerAvatar.setTranslation(xPosBoneco, yPosBoneco);
		lyBalao.setTranslation(xPosBoneco + 200, yPosBoneco - 58);
		//Window.alert("addPosicaoBoneco...");
		//Window.alert("textAvatar.getPosX() = " + textAvatar.getPosX() + ", vai para: [x:" + x + "] = " + (textAvatar.getPosX() + x));
		//Window.alert("textAvatar.getPosY() = " + textAvatar.getPosY());
		textAvatar.setPos(textAvatar.getPosX() + x, textAvatar.getPosY() + y);
		bracoE.setPositionIni(bracoE.getPosXIni() + x, bracoE.getPosYIni() + y);
		bracoE.setBezier(bracoE.getBezierX() + x, bracoE.getBezierY() + y);
		bracoD.setPositionFim(bracoD.getPosXFim() + x, bracoD.getPosYFim() + y);
		bracoD.setBezier(bracoD.getBezierX() + x, bracoD.getBezierY() + y);
		moveMaoE_New(posMEX += x, posMEY += y, rotacaoAdicionalME, riscar);
		moveMaoD_New(posMDX += x, posMDY += y, rotacaoAdicionalMD, riscar);
	}

	private void startMovimentoMaoE(final int x1, final int y1, final float anguloFinal, final int velocidade, final boolean riscar) {
		if (!movingMaoE) {
			movingMaoE = true;

			movMaoEPendenteAtual = new MovimentoMaoPendente(2, x1, y1, anguloFinal, velocidade, riscar);

			errMaoE = new ErrMAO();
			errMaoE.veloc = 2;
			errMaoE.dx = Math.abs(x1-posMEX);
			errMaoE.dy = Math.abs(y1-posMEY);
			errMaoE.numSteps =  Math.floor(Math.abs((x1 - posMEX)) / errMaoE.veloc) > Math.floor(Math.abs((y1 - posMEY)) / errMaoE.veloc)?(int)Math.floor(Math.abs((x1 - posMEX)) / errMaoE.veloc):(int)Math.floor(Math.abs((y1 - posMEY)) / errMaoE.veloc);

			errMaoE.dAng = Math.abs(anguloFinal-rotacaoAdicionalME)/errMaoE.numSteps;
			//setMessageBox("AnguloAtual = " + rotacaoAdicionalME + ", AnguloFinal = " + anguloFinal + ", dAng = " + dAng);

			if (posMEX < x1) {
				errMaoE.sx = errMaoE.veloc;
			} else {
				errMaoE.sx = -errMaoE.veloc;
			}

			if (posMEY < y1) {
				errMaoE.sy = errMaoE.veloc;
			} else {
				errMaoE.sy = -errMaoE.veloc;
			}
			errMaoE.err = errMaoE.dx-errMaoE.dy;

			errMaoE.sAng = (rotacaoAdicionalME <= anguloFinal)?1:-1;

		} else {
			//Agenda esta chamama para um período futuro.
			listMovimentoMaoEPendente.add(new MovimentoMaoPendente(2, x1, y1, anguloFinal, velocidade, riscar));
		}
	}

	private void startMovimentoMaoD(final int x1, final int y1, final float anguloFinal, final int velocidade, final boolean riscar) {
		if (!movingMaoD) {
			movingMaoD = true;
			movMaoDPendenteAtual = new MovimentoMaoPendente(1, x1, y1, anguloFinal, velocidade, riscar);

			errMaoD = new ErrMAO();

			errMaoD.veloc = 2;
			errMaoD.dx = Math.abs(x1-posMDX);
			errMaoD.dy = Math.abs(y1-posMDY);
			errMaoD.numSteps =  Math.floor(Math.abs((x1 - posMDX)) / errMaoD.veloc) > Math.floor(Math.abs((y1 - posMDY)) / errMaoD.veloc)?(int)Math.floor(Math.abs((x1 - posMDX)) / errMaoD.veloc):(int)Math.floor(Math.abs((y1 - posMDY)) / errMaoD.veloc);

			//setMessageBox("numSteps = " + numSteps);
			errMaoD.dAng = Math.abs(anguloFinal-rotacaoAdicionalMD)/errMaoD.numSteps;
			//setMessageBox("AnguloAtual = " + rotacaoAdicionalMD + ", AnguloFinal = " + anguloFinal + ", dAng = " + dAng);

			if (posMDX < x1) {
				errMaoD.sx = errMaoD.veloc;
			} else {
				errMaoD.sx = -errMaoD.veloc;
			}

			if (posMDY < y1) {
				errMaoD.sy = errMaoD.veloc;
			} else {
				errMaoD.sy = -errMaoD.veloc;
			}
			errMaoD.err = errMaoD.dx-errMaoD.dy;

			errMaoD.sAng = (rotacaoAdicionalMD <= anguloFinal)?1:-1;

		} else {
			//Agenda esta chamama para um período futuro.
			listMovimentoMaoDPendente.add(new MovimentoMaoPendente(1, x1, y1, anguloFinal, velocidade, riscar));
		}
	}

	private void moveMaoE_New(int posX, int posY, float anguloAdicional, boolean riscar) {
		//setMessageBox("moveMaoE - inicio: posX:" + posX + ", posY:" + posY + ",anguloAdiconal:" + anguloAdicional);
		//setMessageBox("moveMaoE - inicio: imageMaoE.width:" + imgMaoE.width() + ", imgMaoE.height = " + imgMaoE.height());
		maoE.setImage(imgMaoE);

		float divisor = (((posXBracoE + xPosBoneco - 202) - (float)posX));
		if (divisor == 0) {
			divisor = -0.01f;
		}
		float div = ((posYBracoE + yPosBoneco - 60) - (float)posY) / divisor;
		//setMessageBox("div = " + div);
		maoE.setAngleRotation(Float.parseFloat(String.valueOf(Math.atan(div))) + Float.parseFloat(String.valueOf(anguloAdicional)));

		int px;
		int py;
		float angulo;
		float angPos;

		if ((posX >= (posXBracoE + xPosBoneco - 202)) && ((posY > (posYBracoE + yPosBoneco - 60)) || (maoE.getAngleRotacao() < 0))) {
			angulo = (Float.parseFloat(String.valueOf(maoE.getAngleRotacao())) + Float.parseFloat(String.valueOf(Math.PI)));
		} else {
			angulo = maoE.getAngleRotacao();
		}

		maoE.setPosition(posMEX = posX,  posMEY = posY);
		maoE.setAngle((float)angulo);

		angPos = Float.parseFloat(String.valueOf(angulo)) + Float.parseFloat(String.valueOf(maoE.getAngleBeta()));
		px = (int)(posX + (Math.cos(angPos) * maoE.getHidMedio()));
		py = (int)(posY + (Math.sin(angPos) * maoE.getHidMedio()));
		//setMessageBox("MaoE.angleBeta = " + maoE.getAngleBeta());
		//setMessageBox("anguloPos: [" + angPos + "]");
		//setMessageBox("moveMaoE - px:" + px + ",py:" + py + ",angulo:" + angulo + ", hidMedio:" + maoE.getHidMedio());

		//bracoE.setPosition(posBEX = px, posBEY = py, posXBracoE, posYBracoE);
		bracoE.setPosition(posBEX = px, posBEY = py, xPosBoneco + 50, yPosBoneco + 130);
 
		if (riscar) {
			drawPointOnCanvasImg(cImgDraw, posX, posY, Color.rgb(250, 10, 10));	
		}
	}

	private void moveMaoD_New(int posX, int posY, float anguloAdicional, boolean riscar) {
		maoD.setImage(imgMaoD);
		//setMessageBox("BezierX,Y = (" + bracoD.getBezierX() + ", " + bracoD.getBezierY() + ")");

		float divisor = ((float)posX - (posXBracoD + xPosBoneco - 202));
		if (divisor == 0) {
			divisor = 0.01f;
		}
		float div = ((float)posY - (posYBracoD + yPosBoneco - 60)) / divisor;
		maoD.setAngleRotation(Float.parseFloat(String.valueOf(Math.atan(div))) + Float.parseFloat(String.valueOf(anguloAdicional)));

		float angulo;
		float angPos;

		if (posX >= (posXBracoD + xPosBoneco - 202)) {
			//angulo = (Double.parseDouble(String.valueOf(maoD.getAngleRotacao())) + Double.parseDouble(String.valueOf(Math.PI)));
			angulo = Float.parseFloat(String.valueOf(maoD.getAngleRotacao())) + Float.parseFloat(String.valueOf(Math.PI));
		} else {
			angulo = maoD.getAngleRotacao();
		}

		maoD.setPosition(posMDX = posX, posMDY = posY);
		maoD.setAngle((float)angulo);

		//angPos = Double.parseDouble(String.valueOf(angulo)) - Double.parseDouble(String.valueOf(maoD.getAngleBeta()));
		angPos = Float.parseFloat(String.valueOf(angulo)) - Float.parseFloat(String.valueOf(maoD.getAngleBeta()));

		int px = (int)(posX + (Math.cos(angPos) * maoD.getHidMedio()));
		int py = (int)(posY + (Math.sin(angPos) * maoD.getHidMedio()));	

		//bracoD.setPosition(posXBracoD, posYBracoD, posBDX = px, posBDY = py, bezierDX, bezierDY);
		//bracoD.setPosition(posXBracoD, posYBracoD, posBDX = px, posBDY = py);
		bracoD.setPosition(xPosBoneco + 146, yPosBoneco + 130, posBDX = px, posBDY = py);

		if (riscar) {
			drawPointOnCanvasImg(cImgDraw, posX, posY, Color.rgb(250, 10, 10));
		}
	}

	private void setRecording(boolean recording, boolean reestart) {
		this.recording = recording;
		if (recording) {
			corrigindo = false;
			if (reestart) {
				listPosRecordingD.clear();
				listPosRecordingE.clear();
				listImgDrawD.clear();
				listImgDrawE.clear();
				setMessageBox("Gravacao Iniciada...");
			} else {
				setMessageBox("Adicione mais pontos...");
			}
		}
	}

	private void setCorrigindo(boolean corrigindo) {
		this.corrigindo = corrigindo;
		if (corrigindo) {
			recording = false;
		}
		setMessageBox("Correcao Iniciada...");
	}

	private void sendMsgText(String txt) {
		//Window.alert("entrou no sendMsgText");
		if (textAvatar == null) {
			//Window.alert("textAvatar null");
		}
		textAvatar.prepareSetText(txt);
	}

	private void sendMsgText(String txt, boolean hideOnTime) {
		//Window.alert("dentro do sendMsgText");
		//Window.alert("textAvatar = " + textAvatar);
		textAvatar.prepareSetText(txt, hideOnTime);
	}

	private void gravaExpressaoRecording(String nome) {

		// Regulariza o tamanho das sequencias maoD e maoE
		//while (listPosRecordingE.size() < listPosRecordingD.size()) {
		//	listPosRecordingE.add(listPosRecordingE.get(listPosRecordingE.size() - 1));
		//}

		//while (listPosRecordingD.size() < listPosRecordingE.size()) {
		//	listPosRecordingD.add(listPosRecordingD.get(listPosRecordingD.size() - 1));
		//}

		setMessageBox("Vai salvar as sequencias gravadas...");

		while (listImgDrawD.size() < listImgDrawE.size()) {
			listImgDrawD.add(null);
		}

		while (listImgDrawE.size() < listImgDrawD.size()) {
			listImgDrawE.add(null);
		}
		//*******************************
		setMessageBox("Vai salvar as sequencias gravadas...");

		setMessageBox("Dsize = " + listImgDrawD.size());
		setMessageBox("Esize = " + listImgDrawE.size());

		ArrayList<ExpressaoDB> listExprDB = new ArrayList<ExpressaoDB>(0);
		for (int i = 0; i < listImgDrawD.size(); i++) {

			//PosicaoMaosDB pM = new PosicaoMaosDB(maoD.getMaoId(), nome + "_" + i, maoE.getMaoId(), posD[0], posD[1], posE[0], posE[1], bezierDX, bezierDY, bezierEX, bezierEY, rotacaoAdicionalMD, rotacaoAdicionalME);
			float xD, yD, xE, yE;
			boolean rD, rE;
			if (listImgDrawE.get(i) == null) {
				xE = -1; yE = -1; rE = false; 
			} else {
				xE = listImgDrawE.get(i).imgL.transform().tx(); yE = listImgDrawE.get(i).imgL.transform().ty();
				rE = listImgDrawE.get(i).exprDB.getRiscarE();
			}
			if (listImgDrawD.get(i) == null) {
				xD = -1; yD = -1; rD = false;
			} else {
				xD = listImgDrawD.get(i).imgL.transform().tx(); yD = listImgDrawD.get(i).imgL.transform().ty();
				rD = listImgDrawD.get(i).exprDB.getRiscarD();
			}

			PosicaoOlhoBoneco pOlho = null;
			if (pOlho == null && listImgDrawE.get(i) != null) {
				pOlho = listImgDrawE.get(i).exprDB.getPosicaoOlhoBoneco();
			}
			if (pOlho == null && listImgDrawD.get(i) != null) {
				pOlho = listImgDrawD.get(i).exprDB.getPosicaoOlhoBoneco();
			}
			if (pOlho == null) {
				pOlho = olhos.getPosicaoOlhoAtual();
			}

			PosicaoBoca posBoca = null;
			if (posBoca == null && listImgDrawE.get(i) != null) {
				posBoca = listImgDrawE.get(i).exprDB.getPosicaoBoca();
			}
			if (posBoca == null && listImgDrawD.get(i) != null) {
				posBoca = listImgDrawD.get(i).exprDB.getPosicaoBoca();
			}
			if (posBoca == null) {
				posBoca = boca.getPosicaoBocaAtual();
			}

			MovimentoSobrancelha movSobrancelha = null;
			if (movSobrancelha == null && listImgDrawE.get(i) != null) {
				movSobrancelha = listImgDrawE.get(i).exprDB.getMovimentoSobrancelha();
			}
			if (movSobrancelha == null && listImgDrawD.get(i) != null) {
				movSobrancelha = listImgDrawD.get(i).exprDB.getMovimentoSobrancelha();
			}
			if (movSobrancelha == null) {
				movSobrancelha = sobrancelhas.getMovimentoSobrancelhaAtual();
			}

			//int mId;
			int smD, smE;
			if (listImgDrawE.get(i) == null) {
				//mId = maoE.getMaoId();
				smE = maoE.getSubMaoId(); 
			} else {
				//mId = listImgDrawE.get(i).exprDB.getPosicaoMaos().getMaoId();
				smE = listImgDrawE.get(i).exprDB.getPosicaoMaos().getSubMaoEId();
			}
			if (listImgDrawD.get(i) == null) {
				//mId = maoD.getMaoId();
				smD = maoD.getSubMaoId();
			} else {
				//mId = listImgDrawD.get(i).exprDB.getPosicaoMaos().getMaoId();
				smD = listImgDrawD.get(i).exprDB.getPosicaoMaos().getSubMaoDId();
			}

			float rotD, rotE;
			if (listImgDrawE.get(i) == null) {
				rotE = 0;
			} else {
				rotE = listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE();
			}
			if (listImgDrawD.get(i) == null) {
				rotD = 0;
			} else {
				rotD = listImgDrawD.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoD();
			}

			int bzDX, bzDY, bzEX, bzEY;
			if (listImgDrawE.get(i) == null) {
				bzEX = bracoE.getBezierX(); bzEY = bracoE.getBezierY();
			} else {
				bzEX = listImgDrawE.get(i).exprDB.getPosicaoMaos().getBezierEX();
				bzEY = listImgDrawE.get(i).exprDB.getPosicaoMaos().getBezierEY();
			}
			if (listImgDrawD.get(i) == null) {
				bzDX = bracoD.getBezierX(); bzDY = bracoD.getBezierY();
			} else {
				bzDX = listImgDrawD.get(i).exprDB.getPosicaoMaos().getBezierDX();
				bzDY = listImgDrawD.get(i).exprDB.getPosicaoMaos().getBezierDY();
			}

			int vD, vE;
			if (listImgDrawE.get(i) == null) {
				vE = 2; 
			} else {
				vE = listImgDrawE.get(i).exprDB.getVelocidadeE();
			}
			if (listImgDrawD.get(i) == null) {
				vD = 2;
			} else {
				vD = listImgDrawD.get(i).exprDB.getVelocidadeD();
			}

			PosicaoMaosDB pM = new PosicaoMaosDB(nome + "_" + i, smD, smE, (int)xD, (int)yD, (int)xE, (int)yE, bzDX, bzDY, bzEX, bzEY, rotD, rotE);
			//PosicaoMaosDB pM = new PosicaoMaosDB(maoD.getMaoId(), nome + "_" + i, maoE.getMaoId(), listPosRecordingD.get(i)[0], listPosRecordingD.get(i)[1], listPosRecordingE.get(i)[0], listPosRecordingE.get(i)[1], bezierDX, bezierDY, bezierEX, bezierEY, rotacaoAdicionalMD, rotacaoAdicionalME);
			ExpressaoDB expr = new ExpressaoDB(nome + "_" + i, pM, pOlho, posBoca, movSobrancelha, vD, vE, rD, rE, false);
			listExprDB.add(expr);
		}
		gravaMatrExpressaoDB(listExprDB);
	}

	private double radiansToDegree(double radians) {
		double result = radians * 180 / Math.PI;
		return result;
	}

	private void trocaExpressaoAleatoria() {
		int i = (int)Math.floor(Random.nextDouble() * Expressao.values().length);
		System.out.println("pos id = " + i);
		trocaExpressao(i);
	}

	private ImageLayer criaCaixaFundo() {
		int width = 300;
	    int height = 150;
	    CanvasImage bgImage = graphics().createImage(width, height);
	    Canvas canvas = bgImage.canvas();
	    canvas.setFillColor(0xff87ceeb);
	    //canvas.setStrokeWidth(1);
	    canvas.fillRect(0, 0, width, height);
	    ImageLayer bg = graphics().createImageLayer(bgImage);
	    //bg.setTranslation(1, 1);
	    return bg;
	}

	private CanvasImage criaImage(int width, int height) {
		CanvasImage bgImage = graphics().createImage(width, height);
		//Canvas canvas = bgImage.canvas();
		//canvas.setFillColor(0xff87ceeb);
		//canvas.fillRect(0, 0, width, height);
		//ImageLayer bg = graphics().createImageLayer(bgImage);
		return bgImage;
	}

	private ImageLayer getTextBox(String texto) {
		int width = 100;
	    int height = 50;
	    CanvasImage bgI = graphics().createImage(width, height);
	    Canvas canv = bgI.canvas();
	    //canvas.setFillColor(Color.rgb(200, 200, 200));
	    //canvas.setFillColor(0xff87ceeb);
	    //Font f = graphics().createFont("Times", Style.BOLD, 24f);
	    //TextLayout t = graphics().layoutText("teste2", new TextFormat().withFont(f));
	    //canv.drawText(t, 0, 0);

	    //f = graphics().createFont("Arial", Style.BOLD_ITALIC, 8f);
	    //t = graphics().layoutText("teste2", new TextFormat().withFont(f));
	    canv.drawText(texto, 10, 10);

	    ImageLayer bgl = graphics().createImageLayer(bgI);
	    //bg.setTranslation(1, 1);
	    return bgl;
	}

	private ImageLayer getGrid() {
		int width = 600;
	    int height = 300;
	    CanvasImage bgI = graphics().createImage(width, height);
	    Canvas canv = bgI.canvas();
	    //canvas.setFillColor(Color.rgb(200, 200, 200));
	    //canvas.setFillColor(0xff87ceeb);
	    //Font f = graphics().createFont("Times", Style.BOLD, 24f);
	    //TextLayout t = graphics().layoutText("teste2", new TextFormat().withFont(f));
	    //canv.drawText(t, 0, 0);

	    //f = graphics().createFont("Arial", Style.BOLD_ITALIC, 8f);
	    //t = graphics().layoutText("teste2", new TextFormat().withFont(f));
	    for (int i = 0; i < 600; i+=30) {
	    	canv.drawLine(i, 0, i, 300);
	    }
    	for (int j = 0; j < 300; j+=30) {
    		canv.drawLine(0, j, 600, j);
    	}

	    ImageLayer bgl = graphics().createImageLayer(bgI);
	    //bg.setTranslation(1, 1);
	    return bgl;
	}

	private void trocaAvatarAleatorio(boolean update) {
		setAvatar(ClientUtils.getRandomAvatar(), update);
	}

	private void trocaParteAvatarAleatorio(String parte) {
		setParteAvatar(parte, ClientUtils.getRandomAvatar());
	}

	private void trocaProximaParteAvatar(String parte) {
		setProximaParteAvatar(parte);
	}

	private String getStringAvatar() {
		if (avatarAtual == null) {
			//Window.alert("avatar nulo");
			trocaAvatarAleatorio(true);
		}
		return avatarAtual.toString();
	}

	private void setProximaParteAvatar(String parte) {

	    Image imgCabTmp = null;
	    Image imgRoupTmp = null;
	    Image imgbracoTmp = null;

	    //Window.alert("Cabelo.lenght = " + Avatar.Cabelo.values().length + ", atual = " + this.avatarAtual.getCodParteCabelo());

		if (parte.equals("tudo") || parte.equals("cabelo")) {
			int codNovaParte = (this.avatarAtual.getCodParteCabelo() >= Avatar.Cabelo.values().length)?1:(this.avatarAtual.getCodParteCabelo() + 1);   
			this.avatarAtual.setCodParteCabelo(codNovaParte);
			imgCabTmp = assets().getImage("/images/avatar/cabelo/cabelo" + codNovaParte + ".png");
		}

		if (parte.equals("tudo") || parte.equals("sobrancelha")) {
			int codNovaParte = (this.avatarAtual.getCodParteSobrancelha() >= Avatar.Sobrancelha.values().length)?1:this.avatarAtual.getCodParteSobrancelha() + 1;
			this.avatarAtual.setCodParteSobrancelha(codNovaParte);
			trocaEstiloSobrancelha(codNovaParte);
		}

		if (parte.equals("tudo") || parte.equals("olho")) {
			int codNovaParte = (this.avatarAtual.getCodParteOlho() >= Avatar.Olho.values().length)?1:this.avatarAtual.getCodParteOlho() + 1;
			this.avatarAtual.setCodParteOlho(codNovaParte);
			trocaEstiloOlho(codNovaParte);
		}
		
		if (parte.equals("tudo") || parte.equals("boca")) {
			int codNovaParte = (this.avatarAtual.getCodParteBoca() >= Avatar.EstiloBoca.values().length)?1:this.avatarAtual.getCodParteBoca() + 1;
			this.avatarAtual.setCodParteBoca(codNovaParte);
			trocaEstiloBoca(codNovaParte);
		}

		if (parte.equals("tudo") || parte.equals("roupa")) {
			int codNovaParte = (this.avatarAtual.getCodParteRoupa() >= Avatar.Roupa.values().length)?1:this.avatarAtual.getCodParteRoupa() + 1;
			this.avatarAtual.setCodParteRoupa(codNovaParte);
			imgRoupTmp = assets().getImage("/images/avatar/roupa/roupa" + codNovaParte + ".png");
			imgbracoTmp = assets().getImage("/images/avatar/roupa/braco" + codNovaParte + ".png");
		}

	    final Image imgCab = imgCabTmp;
	    final Image imgRoup = imgRoupTmp;
	    final Image imgBrac = imgbracoTmp;

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				System.out.println("Erro ao carregar as imagens...");
			}

			@Override
			public void done() {
				if (imgCab != null) {
					imgCabelo = imgCab;
					lyCabelo.setImage(imgCabelo);
					//Window.alert("cabelo height = " + imgCabelo.height());
					Cabelo cab = Cabelo.getCabeloPorId(avatarAtual.getCodParteCabelo());
					if (imgCabelo.height() > 28) {
						float cabPosY = ((28 - imgCabelo.height()) / 2) + cab.getAditionalTop();
						lyCabelo.setTranslation(cab.getAditionalLeft(), cabPosY);
					} else {
						lyCabelo.setTranslation(cab.getAditionalLeft(), cab.getAditionalTop());
					}
				}
			    if (imgRoup != null) {
			    	float posRoupa = (imgCorpo.width() - imgRoup.width()) / 2;
			    	Roupa roupa = Roupa.getRoupaPerId(avatarAtual.getCodParteRoupa());
			    	lyRoupa.setImage(imgRoup);
			    	lyRoupa.setTranslation(posRoupa + roupa.getAditionalLeft(), 118 + roupa.getAditionalTop());
			    	imgRoupa = imgRoup;
			    	bracoD.setImageBraco(imgBrac);
			    	bracoE.setImageBraco(imgBrac);
			    }
			}
		});

		if (imgCab != null) {
			as.add(imgCab);
		}
		if (imgRoup != null) {
			as.add(imgRoup);
			as.add(imgBrac);
		}
		as.start();
	}

	private void setParteAvatar(String parte, final Avatar av) {

	    Image imgCabTmp = null;
	    Image imgRoupTmp = null;
	    Image imgbracoTmp = null;

		if (parte.equals("tudo") || parte.equals("cabelo")) {
			this.avatarAtual.setCodParteCabelo(av.getCodParteCabelo());
			imgCabTmp = assets().getImage("/images/avatar/cabelo/cabelo" + av.getCodParteCabelo() + ".png");
		}

		if (parte.equals("tudo") || parte.equals("sobrancelha")) {
			this.avatarAtual.setCodParteSobrancelha(av.getCodParteSobrancelha());
			trocaEstiloSobrancelha(av.getCodParteSobrancelha());
		}

		if (parte.equals("tudo") || parte.equals("olho")) {
			this.avatarAtual.setCodParteOlho(av.getCodParteOlho());
			trocaEstiloOlho(av.getCodParteOlho());
		}
		
		if (parte.equals("tudo") || parte.equals("boca")) {
			this.avatarAtual.setCodParteBoca(av.getCodParteBoca());
			trocaEstiloBoca(av.getCodParteBoca());
		}

		if (parte.equals("tudo") || parte.equals("roupa")) {
			this.avatarAtual.setCodParteRoupa(av.getCodParteRoupa());
			imgRoupTmp = assets().getImage("/images/avatar/roupa/roupa" + av.getCodParteRoupa() + ".png");
			imgbracoTmp = assets().getImage("/images/avatar/roupa/braco" + av.getCodParteRoupa() + ".png");
		}

	    final Image imgCab = imgCabTmp;
	    final Image imgRoup = imgRoupTmp;
	    final Image imgBrac = imgbracoTmp;

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				System.out.println("Erro ao carregar as imagens...");
			}

			@Override
			public void done() {
				if (imgCab != null) {
					imgCabelo = imgCab;
					lyCabelo.setImage(imgCabelo);
					//Window.alert("cabelo height = " + imgCabelo.height());
					Cabelo cab = Cabelo.getCabeloPorId(av.getCodParteCabelo());
					if (imgCabelo.height() > 28) {
						float cabPosY = ((28 - imgCabelo.height()) / 2) + cab.getAditionalTop();
						lyCabelo.setTranslation(cab.getAditionalLeft(), cabPosY);
					} else {
						lyCabelo.setTranslation(cab.getAditionalLeft(), cab.getAditionalTop());
					}
				}
			    if (imgRoup != null) {
			    	float posRoupa = (imgCorpo.width() - imgRoup.width()) / 2;
			    	Roupa roupa = Roupa.getRoupaPerId(avatarAtual.getCodParteRoupa());
			    	lyRoupa.setImage(imgRoup);
			    	lyRoupa.setTranslation(posRoupa + roupa.getAditionalLeft(), 118 + roupa.getAditionalTop());
			    	imgRoupa = imgRoup;
			    	bracoD.setImageBraco(imgBrac);
			    	bracoE.setImageBraco(imgBrac);
			    }
			}
		});

		if (imgCab != null) {
			as.add(imgCab);
		}
		if (imgRoup != null) {
			as.add(imgRoup);
			as.add(imgBrac);
		}
		as.start();
	}

	private void setAvatar(final String strAv, boolean update) {
		System.out.println("strAv = " + strAv);
		Avatar av = Avatar.getAvatar(strAv);
		if (av == null) {
			System.out.println("strAv null ");
			//setAvatar(av);
		} else {
			System.out.println("avatar  ok");
			setAvatar(av, update);
		}
	}

	private void setAvatar(final Avatar av, final boolean update) {

		if (!trocandoAvatar && !trocandoSequencia) {

			trocandoAvatar = true;
			this.avatarAtual = av;

			if (update) {

				final Image imgCab = assets().getImage("/images/avatar/cabelo/cabelo" + av.getCodParteCabelo() + ".png");
			    //final Image imgSobran = assets().getImage("/images/avatar/sombrancelha/sobran" + av.getCodParteSobrancelha() + ".png");
			    trocaEstiloSobrancelha(av.getCodParteSobrancelha());
			    //final String pathOlh = "/images/avatar/olho/" + av.getCodParteOlho() + "/olho" + av.getCodParteOlho() + pOlhoAtual.getArquivo(); 
			    //final Image imgOlho = assets().getImage(pathOlh);
			    trocaEstiloOlho(av.getCodParteOlho());
			    final Image imgMaoD = assets().getImage("/images/avatar/mao/" + av.getCodParteMao() + "/mao" + maoD.getSubMaoId() + ".png");
			    final Image imgMaoE = assets().getImage("/images/avatar/mao/" + av.getCodParteMao() + "/mao" + maoE.getSubMaoId() + ".png");
			    final Image imgRoup = assets().getImage("/images/avatar/roupa/roupa" + av.getCodParteRoupa() + ".png");
			    final Image imgBrac = assets().getImage("/images/avatar/roupa/braco" + av.getCodParteRoupa() + ".png");
			    //final Image imgBoc = assets().getImage("/images/avatar/boca/" + av.getCodParteBoca() + "/boca" + posBocaAtual.getId() + ".png");
			    trocaEstiloBoca(av.getCodParteBoca());

				AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
					@Override
					public void error(Throwable e) {
						System.out.println("Erro ao carregar as imagens...");
					}

					@Override
					public void done() {
						imgCabelo = imgCab;
					    lyCabelo.setImage(imgCabelo);
					    //Window.alert("cabelo height = " + imgCabelo.height());
					    Cabelo cab = Cabelo.getCabeloPorId(av.getCodParteCabelo()); 
					    if (imgCabelo.height() > 28) {
					    	float cabPosY = ((28 - imgCabelo.height()) / 2) + cab.getAditionalTop();
					    	lyCabelo.setTranslation(cab.getAditionalLeft(), cabPosY);
					    } else {
					    	lyCabelo.setTranslation(cab.getAditionalLeft(), cab.getAditionalTop());
					    }
					    //pathOlho = pathOlh;
					    //imgOlhoE = imgOlho;
					    //imgOlhoD = imgOlho;
					    //lyOlhoE.setImage(imgOlhoE);
					    //lyOlhoD.setImage(imgOlhoD);
					    //Window.alert("imgRoupa.width = " + imgRoup.width());
					    float posRoupa = (imgCorpo.width() - imgRoup.width()) / 2;
				    	Roupa roupa = Roupa.getRoupaPerId(avatarAtual.getCodParteRoupa());
				    	lyRoupa.setImage(imgRoup);
				    	lyRoupa.setTranslation(posRoupa + roupa.getAditionalLeft(), 118 + roupa.getAditionalTop());
					    imgRoupa = imgRoup;
					    imgBraco = imgBrac;
					    bracoE.setImageBraco(imgBrac);
					    bracoD.setImageBraco(imgBrac);

					    //imgBoca = imgBoc;
					    //imgSombrancelhaD = imgSobran;
					    //imgSombrancelhaE = imgSobran;
					    //lyBoca.setImage(imgBoc);
					    //float posBoca = (imgCorpo.width() - imgBoca.width()) / 2;
					    //Window.alert("posBoca = " + posBoca);
					    //lyBoca.setTranslation(posBoca, 94);
					    //lySombrancelhaE.setImage(imgSombrancelhaE);
					    //lySombrancelhaD.setImage(imgSombrancelhaD);
					    //lySombrancelhaD.setScale(-1, 1);
					    //lySombrancelhaD.setTranslation(50 + 2*imgSombrancelhaD.width(), 38);

					    maoE.setImage(imgMaoE);
					    maoD.setImage(imgMaoD);

					    trocandoAvatar = false;
					    //Window.alert("Trocando Avatar fim! trocandoAvatar = " + trocandoAvatar);
					}
				});
	
				as.add(imgCab);
				//as.add(imgSobran);
				//as.add(imgOlho);
				as.add(imgRoup);
				as.add(imgBrac);
				as.add(imgMaoD);
				as.add(imgMaoE);
				//as.add(imgBoc);
				as.start();
			} else {
				trocandoAvatar = false;
				//Window.alert("Trocando Avatar fim! trocandoAvatar = " + trocandoAvatar);
			}

		} else {
			//Agenda
			listSetAvatarPendente.add(new AvatarPendente(av, update));
		}
	}

	public void setRisca(boolean riscar) {
		this.riscar = riscar;
	}

	public void setImage() {

	    setMessageBox("setImage()...");

	    layerAvatar = graphics().createGroupLayer();
	    layerAvatar.setTranslation(xPosBoneco, yPosBoneco);

	    lyDraw = graphics().createGroupLayer();
	    imgLayerDraw = graphics().createImageLayer(cImgDraw);
	    lyDraw.add(imgLayerDraw);

	    lyBalao = graphics().createGroupLayer();

		lyTrocaAvatar = graphics().createGroupLayer();

		lyGrid = graphics().createGroupLayer();
	    layerMaos = graphics().createGroupLayer();
	    layerCheeks = graphics().createGroupLayer();

	    imgCorpo = assets().getImage("/images/avatar/corpo/corpo4.png");
	    imgCabelo = assets().getImage("/images/avatar/cabelo/cabelo10.png");
	    final Image imgSombrancelha = assets().getImage("/images/avatar/sombrancelha/sobran1.png");
	    //imgSombrancelhaE = assets().getImage("/images/avatar/sombrancelha/sobran1.png");
	    final Image imgOlho = assets().getImage("/images/avatar/olho/1/olho1_AB.png");
	    //imgOlhoE = assets().getImage("/images/avatar/olho/1/olho1_AB.png");
	    imgBoca = assets().getImage("/images/avatar/boca/2/boca6.png");
	    imgRoupa = assets().getImage("/images/avatar/roupa/roupa1.png");
	    imgMaoE = assets().getImage("/images/avatar/mao/2/mao2.png");
	    imgMaoD = assets().getImage("/images/avatar/mao/2/mao2.png");
	    imgBraco = assets().getImage("/images/avatar/roupa/braco1.png");
	    imgCheeks = assets().getImage("/images/avatar/cheeks/cheeks1.png");
	    final Image bgImage = assets().getImage("/images/bg.png");
	    final Image balaoImage = assets().getImage("/images/balao-final.png");

	    AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens...");
			}

			@Override
			public void done() {

			    ImageLayer balaoLayer = graphics().createImageLayer(balaoImage);
			    lyBalao.add(balaoLayer);
			    lyBalao.setTranslation(xPosBoneco + 200, yPosBoneco - 58);

			    lyTrocaAvatar.setTranslation(0, 0);

			    posMDX = 400;
			    posMDY = 200;
			    posMEX = 30;
			    posMEY = 200;
				maoE = new Mao(1, 4, posMEX, posMEY, 0, imgMaoE, 1, 1);
			    maoD = new Mao(1, 5, posMDX, posMDY, 0, imgMaoD, 1, -1);
			    //setMessageBox("criou as maos...");
			    //lyMaoE = maoE.getLayer();
			    //lyMaoD = graphics().createImageLayer(imgMaoD);
			    //lyMaoD.setScale(-1, 1);
			    //lyMaoD.setTranslation(220 + imgMaoD.width(), 80);
			    layerMaos.add(maoE.getLayer());
			    layerMaos.add(maoD.getLayer());

			    //lyBracoE = new ImageLayer[11];
			    //lyBracoD = new ImageLayer[11];
			    bracoE = new Braco(11, 0, 0, 10, 10, 0, imgBraco);
			    bracoE.setBezier(190, 190);
			    bracoE.setVisible(false);
			    bracoD = new Braco(11, 0, 0, 10, 10, 0, imgBraco);
			    bracoD.setBezier(400, 210);
			    bracoD.setVisible(false);

			    ImageLayer lyCorpo = graphics().createImageLayer(imgCorpo);
			    layerAvatar.add(lyCorpo);

			    olhos = new Olhos(102, 46, 58, 46, imgOlho, 1, 1);
			    layerAvatar.add(olhos.getLayerOlhoE());
			    layerAvatar.add(olhos.getLayerOlhoD());

			    sobrancelhas = new Sobrancelhas(1, 1, 46 - (imgSombrancelha.width() - 51) + 2*imgSombrancelha.width() - olhos.getEstiloOlhoAtual().getAproximacaoOlho(), 38, 50 - (imgSombrancelha.width() - 51) + olhos.getEstiloOlhoAtual().getAproximacaoOlho(), 38, imgSombrancelha); 
			    layerAvatar.add(sobrancelhas.getLayerSobranE());
			    layerAvatar.add(sobrancelhas.getLayerSobranD());
			    //sobrancelhas.getLayerSobranE().setTranslation(50, 38);
			    //sobrancelhas.getLayerSobranD().setTranslation(50 + 2*imgSombrancelha.width(), 38);

			    boca = new Boca(imgCorpo.width(), 1, 1, 0, 0, imgBoca);
			    layerAvatar.add(boca.getLayer());

			    lyCheekE = graphics().createImageLayer(imgCheeks);
			    lyCheekE.setTranslation(50, 84);
			    lyCheekD = graphics().createImageLayer(imgCheeks);
			    lyCheekD.setScale(-1, 1);
			    lyCheekD.setTranslation(130 + imgCheeks.width(), 84);
			    layerCheeks.add(lyCheekE);
			    layerCheeks.add(lyCheekD);

			    layerAvatar.add(layerCheeks);

			    lyRoupa = graphics().createImageLayer(imgRoupa);
			    layerAvatar.add(lyRoupa);
			    float posRoupa = (imgCorpo.width() - imgRoupa.width()) / 2;
			    lyRoupa.setTranslation(posRoupa, 118);

			    lyCabelo = graphics().createImageLayer(imgCabelo);
			    layerAvatar.add(lyCabelo);
			    //Window.alert("cabelo height = " + imgCabelo.height());
			    if (imgCabelo.height() > 28) {
			    	float cabPosY = (28 - imgCabelo.height()) / 2;
			    	lyCabelo.setTranslation(0, cabPosY);
			    } else {
			    	lyCabelo.setTranslation(0, 0);
			    }

			    
				setBackground(bgImage);
			    addLayers();
			    setVisible(false);
			    setButtonsTrocaAvatarVisible(false);
			    //Window.alert("setimage ok");
			    moveMaoD_New(posMDX, posMDY, rotacaoAdicionalMD, false);
			    moveMaoE_New(posMDX, posMDY, rotacaoAdicionalMD, false);
			}
		});
	    as.add(imgCorpo);
	    as.add(imgCabelo);
	    as.add(imgSombrancelha);
	    as.add(imgOlho);
	    as.add(imgBoca);
	    as.add(imgRoupa);
		as.add(imgMaoD);
		as.add(imgMaoE);
		as.add(imgBraco);
		as.add(imgCheeks);
		as.add(bgImage);
		as.add(balaoImage);
		as.start();   
	}

	public void addLayers() {
		//remove first
		graphics().rootLayer().clear();
		if (bgLayer != null) {
		    for (int i = 0; i < bgLayer.length; i++) {
		    	for (int j = 0; j < bgLayer[i].length; j++) {
				    graphics().rootLayer().add(bgLayer[i][j]);
		    	}
		    }
		}
		//Window.alert("adding lyAvatar");
	    graphics().rootLayer().add(layerAvatar);

	    //Window.alert("adding lyBalao");
	    graphics().rootLayer().add(lyBalao);

	    //Window.alert("screen textAvatar");
		textAvatar = new TextAvatar(_screens, lyBalao);
	    _screens.push(textAvatar);

	    //Window.alert("adding lyTrocaAvatar");
	    graphics().rootLayer().add(lyTrocaAvatar);

	    //Window.alert("screen trocaavatar");
		trocaAvatar = new TrocaAvatar(_screensTrocaAvatar, lyTrocaAvatar);
	    _screensTrocaAvatar.push(trocaAvatar);

	    //Window.alert("adding bracoE");
	    graphics().rootLayer().add(bracoE.getGroupLayer());

	    //Window.alert("adding bracoD");
	    graphics().rootLayer().add(bracoD.getGroupLayer());

	    //Window.alert("adding lyMaos");
	    graphics().rootLayer().add(layerMaos);

	    //Window.alert("adding lyGrid");
	    graphics().rootLayer().add(lyGrid);

	    //Window.alert("adding lyDraw");
	    graphics().rootLayer().add(lyDraw);
	}

	public void setVisible(boolean visible) {
		this.visible = visible;
		layerAvatar.setVisible(visible);
		lyBalao.setVisible(visible);
		layerMaos.setVisible(visible);
		if (bracoD != null) {
			bracoD.setVisible(visible);
		}
		if (bracoE != null) {
			bracoE.setVisible(visible);
		}
		if (textAvatar != null) {
			textAvatar.setVisible(visible);
		}
	}

	public void moveBackground(int x, int y) {
		//Window.alert("bgLayer.width = " + bgLayer[0][0].width());
		//Window.alert("x = " + x);
		//Window.alert("x mod width = " + (x % bgLayer[0][0].width()));
		xMovBackground = x;
		yMovBackground = y;
		float startPosX = x % bgLayer[0][0].width();
		float startPosY = y % bgLayer[0][0].height();
		for (int i = 0; i < bgLayer.length; i++) {
	    	for (int j = 0; j < bgLayer[i].length; j++) {
			    //bgLayer[i][j].setTranslation(-x * (i + 1), -y * (j + 1));
	    		bgLayer[i][j].setTranslation(-startPosX + (bgLayer[0][0].width() * (i)), -startPosY + (bgLayer[0][0].height() * (j)));
	    	}
	    }
	}

	public void scaleBackground(float scaleX, float scaleY) {
		for (int i = 0; i < bgLayer.length; i++) {
	    	for (int j = 0; j < bgLayer[i].length; j++) {
			    //bgLayer[i][j].setTranslation(-x * (i + 1), -y * (j + 1));
	    		bgLayer[i][j].setScale(scaleX, scaleY);
	    	}
	    }
	}

	public void setBackgroundAndMove(String imageUrl, final int xMov, final int yMov) {
		backgroundCarregado = false;
		final Image bgImage = assets().getImage(imageUrl);
		//Window.alert("setBackground em testplayn game");
	    AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens...");
			}

			@Override
			public void done() {
				//Window.alert("done..");

			    //bgLayer.setImage(bgImage);
				xMovBackground = xMov;
				yMovBackground = yMov;
				setBackground(bgImage);
				moveBackground(xMov, yMov);
				addLayers();
			    backgroundCarregado = true;
			}
	    });
	    as.add(bgImage);
	    as.start();
	}

	public void setBackground(String imageUrl) {
		backgroundCarregado = false;
		final Image bgImage = assets().getImage(imageUrl);
		//Window.alert("setBackground em testplayn game");
	    AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens...");
			}

			@Override
			public void done() {
				//Window.alert("done..");

			    //bgLayer.setImage(bgImage);
				setBackground(bgImage);
				addLayers();
			    backgroundCarregado = true;
			}
	    });
	    as.add(bgImage);
	    as.start();
	}

	public void setBackground(Image bgImage) {
		//Window.alert("iniciando background..");
		//remover primeiro
		/*
		Window.alert("removendo.." + bgImage);
		
		if (bgLayer != null) {
		    for (int i = 0; i < bgLayer.length; i++) {
		    	for (int j = 0; j < bgLayer[i].length; j++) {
				    graphics().rootLayer().remove(bgLayer[i][j]);
		    	}
		    }
		}
		*/

		int rowBG = 1;
		int colBG = 1;
		//Window.alert("iniciando background..bgImage.width() = " + bgImage.width() + ", bgImage.height() = " + bgImage.height() + ", gameWidth = " + (getWidth() + xMovBackground) + ", gameHeight = " + (getHeight() + yMovBackground) );
		if (getWidth() + xMovBackground > bgImage.width()) {
			colBG = (int)Math.floor((getWidth() + xMovBackground) / bgImage.width()) + 1;
		}
		if (getHeight() + yMovBackground > bgImage.height()) {
			rowBG = (int)Math.floor((getHeight() + yMovBackground) / bgImage.height()) + 1;
			//Window.alert("RowBG = " + rowBG);
		}

		//Window.alert("colBG = " + colBG + ", rowBG = " + rowBG);
		bgLayer = new ImageLayer[colBG][rowBG];
		for (int i = 0; i < rowBG; i++) {
			for (int j = 0; j < colBG; j++) {
				bgLayer[j][i] = graphics().createImageLayer(bgImage);
				//bgLayer[i][j].setDepth(0);
				bgLayer[j][i].setTranslation(j*bgImage.height(), i*bgImage.width());
				//graphics().rootLayer().add(bgLayer[i][j]);
				//Window.alert("bgLayer[i][j].(x, y) = (" + j + "," + i + ")(" + j*bgImage.height() + ", " + i*bgImage.width() + ")");
			}
		}
		//Window.alert("fim background..");
	}

	public void trocaPosicaoBoca(int posBocaId) {
		//Window.alert("Trocando Posicao Boca: " + posBocaId);
		PosicaoBoca posBC = PosicaoBoca.getPosicaoBocaPorId(posBocaId);
		boca.trocaPosicaoBoca(posBC);
	}

	public void trocaEstiloBoca(int estiloBocaId) {
		//Window.alert("Trocando estilo boca: " + estiloBocaId);
		EstiloBoca bc = EstiloBoca.getBocaPorId(estiloBocaId);
		boca.trocaEstiloBoca(bc);
	}

	public void trocaPosicaoMaos(int posMaos) {
		PosicaoMaos pM = PosicaoMaos.getPosicaoMaosPerId(posMaos);
		trocaPosicaoMaos(pM);
	}

	public void trocaEstiloSobrancelha(int estiloSobrancelhaId) {
		Sobrancelha sobr = Sobrancelha.getSobrancelhaPorId(estiloSobrancelhaId);
		sobrancelhas.trocaEstiloSobrancelha(sobr);
	}

	public void trocaMovimentoSobrancelha(int sobrancelhaId) {
		MovimentoSobrancelha movSobr = MovimentoSobrancelha.getMovimentoSobrancelhaId(sobrancelhaId);
		sobrancelhas.trocaMovimentoSobrancelha(movSobr);
	}

	public void trocaEstiloOlho(int estiloOlhoId) {
		Olho estOlho = Olho.getOlhoPerId(estiloOlhoId);
		olhos.trocaEstiloOlho(estOlho);
	}

	public void trocaPosicaoOlho(int posOlhoId) {
		PosicaoOlhoBoneco pOlho = PosicaoOlhoBoneco.getPosicaoOlhoPerId(posOlhoId);
		olhos.trocaPosicaoOlho(pOlho);
	}

	public void drawPoint(int xDest, int yDest) {
		Window.alert("draw point...");
		//lyBracoD[0].setTranslation(xDest - (lyBracoD[0].width() / 2), yDest - (lyBracoD[0].height() / 2));
	}

	public void drawPoint(CanvasImage canvasImg, int xDest, int yDest, int c) {
	    canvasImg.canvas().setFillColor(c);
	    //canvasImg.canvas().drawPoint(xDest, yDest);
	    canvasImg.canvas().drawLine(xDest, yDest, xDest+5, yDest+5);
	}

	public CanvasImage drawNewPoint(int xDest, int yDest, int c) {
		CanvasImage canvasImg = graphics().createImage(2, 2);
	    canvasImg.canvas().setFillColor(c);
	    //canvasImg.canvas().drawPoint(xDest, yDest);
	    //canvasImg.canvas().drawLine(xDest, yDest, xDest+5, yDest+5);
	    canvasImg.canvas().drawLine(1, 1, 2, 2);
	    //canvasImg.canvas().drawPoint(1, 1);
	    return canvasImg;
	}

	public void drawPointOnCanvasImg(CanvasImage canvasImg, int xDest, int yDest, int c) {
	    canvasImg.canvas().setFillColor(c);
	    //canvasImg.canvas().drawPoint(xDest, yDest);
	    //canvasImg.canvas().drawLine(xDest, yDest, xDest+5, yDest+5);
	    canvasImg.canvas().drawLine(xDest, yDest, xDest + 1, yDest + 1);
	    //canvasImg.canvas().drawPoint(1, 1);
	}

	public CanvasImage drawNumber(int xDest, int yDest, int c, int number) {
		CanvasImage canvasImg = graphics().createImage(100, 100);
	    //canvasImg.canvas().setFillColor(c);
	    //canvasImg.canvas().drawPoint(xDest, yDest);
	    canvasImg.canvas().drawText(String.valueOf(number), xDest, yDest);
	    //canvasImg.canvas().drawLine(xDest, yDest, xDest+5, yDest+5);
	    return canvasImg;
	}

	@Override
	public void paint(float alpha) {
		// the background automatically paints itself, so no need to do anything here!

		//if (maoD != null) {
		//	maoD.paint(alpha);
		//}

		//if (maoE != null) {
		//	maoE.paint(alpha);
		//}

		//if (olhos != null) {
		//	olhos.paint(alpha);
		//}

		//if (sobrancelhas != null) {
		//	sobrancelhas.paint(alpha);
		//}

		//if (boca != null) {
		//	boca.paint(alpha);
		//}

		if (trocaAvatar.getVisible()) {
			_screensTrocaAvatar.paint(alpha);
		}

		if (textAvatar.getVisible()) {
			_screens.paint(alpha);
		}
	}

	@Override
	public void update(float delta) {

		if (movingMaoD) {
			moveMaoD_New(posMDX, posMDY, rotacaoAdicionalMD, movMaoDPendenteAtual.getRiscar());

			errMaoD.cont++;
			if (Math.abs(posMDX - movMaoDPendenteAtual.getX1()) < errMaoD.veloc && Math.abs(posMDY - movMaoDPendenteAtual.getY1()) < errMaoD.veloc) {
				movingMaoD = false;
			}

			if (movingMaoD) {
				int e2 = 2*errMaoD.err;
				if (e2 > -errMaoD.dy) { 
					errMaoD.err = errMaoD.err - errMaoD.dy;
					posMDX += errMaoD.sx;
				}
				if (e2 < errMaoD.dx) {
					errMaoD.err = errMaoD.err + errMaoD.dx;
					posMDY += errMaoD.sy;
				}
				rotacaoAdicionalMD = rotacaoAdicionalMD + (errMaoD.sAng * errMaoD.dAng);
			}
		} else {
			if (listMovimentoMaoDPendente.size() > 0) {
				MovimentoMaoPendente mov = listMovimentoMaoDPendente.removeFirst();
				startMovimentoMaoD(mov.getX1(), mov.getY1(), mov.getAnguloFinal(), mov.getVelocidade(), mov.getRiscar());
			}
		}

		if (movingMaoE) {
			moveMaoE_New(posMEX, posMEY, rotacaoAdicionalME, movMaoEPendenteAtual.getRiscar());

			if (Math.abs(posMEX - movMaoEPendenteAtual.getX1()) < errMaoE.veloc && Math.abs(posMEY - movMaoEPendenteAtual.getY1()) < errMaoE.veloc) {
				movingMaoE = false;
			}

			if (movingMaoE) {
				int e2 = 2*errMaoE.err;
				if (e2 > -errMaoE.dy) { 
					errMaoE.err = errMaoE.err - errMaoE.dy;
					posMEX += errMaoE.sx;
				}
				if (e2 < errMaoE.dx) { 
					errMaoE.err = errMaoE.err + errMaoE.dx;
					posMEY += errMaoE.sy; 
				}

				rotacaoAdicionalME = rotacaoAdicionalME + (errMaoE.sAng * errMaoE.dAng);
			}
		} else {
			if (listMovimentoMaoEPendente.size() > 0) {
				MovimentoMaoPendente mov = listMovimentoMaoEPendente.removeFirst();
				startMovimentoMaoE(mov.getX1(), mov.getY1(), mov.getAnguloFinal(), mov.getVelocidade(), mov.getRiscar());
			}
		}

		if (maoD != null) {
			maoD.update(delta);
		}

		if (maoE != null) {
			maoE.update(delta);
		}

		if (bracoD != null) {
			bracoD.update(delta);
		}

		if (bracoE != null) {
			bracoE.update(delta);
		}

		if (olhos != null) {
			olhos.update(delta);
		}

		if (sobrancelhas != null) {
			sobrancelhas.setAproximacaoOlhos(olhos.getEstiloOlhoAtual().getAproximacaoOlho());
			sobrancelhas.update(delta);
		}

		if (boca != null) {
			boca.update(delta);
		}

		if (imgCheeks != null) {
			lyCheekE.setTranslation(50 + olhos.getEstiloOlhoAtual().getAproximacaoOlho(), 84);
		    lyCheekD.setTranslation(130 + imgCheeks.width() - olhos.getEstiloOlhoAtual().getAproximacaoOlho(), 84);
		}

		_screensTrocaAvatar.update(delta);

		if (textAvatar.getVisible()) {
			textAvatar.myUpdate(delta);
			_screens.update(delta);
		}

		if (comportamentoAleatorio) {
			if (tempoComportamentoAleatorio > tempoDisparaComportamentoAleatorio) {
				tempoComportamentoAleatorio = 0;
				double rnd = Random.nextDouble() ;
				if (rnd < 0.3) {
					if (nivelComportamentoAleatorio >= 1) {
						olhos.pisca();  //  nivel 1 ou menor
					}
				} else if (rnd < 0.4) {
					if (nivelComportamentoAleatorio >= 2) {
						boca.trocaBocaTemporaria(PosicaoBoca.getRandom(), 300);
					}
				} else if (rnd < 0.5) {
					if (nivelComportamentoAleatorio >= 3) {
						sobrancelhas.trocaSobrancelhaTemporaria(MovimentoSobrancelha.SOBRANCELHA_ROTACAO_BRAVO_AMBAS, 1000);
					}
				} else if (rnd < 0.6) {
					if (nivelComportamentoAleatorio >= 4) {
						olhos.trocaOlhoTemporario(PosicaoOlhoBoneco.getRandom(), 2000);
						boca.trocaBocaTemporaria(PosicaoBoca.getRandom(), 300);
					}
				} else if (rnd < 0.7) {
					if (nivelComportamentoAleatorio >= 5) {
						olhos.trocaOlhoTemporario(PosicaoOlhoBoneco.getRandom(), 2000);
						boca.trocaBocaTemporaria(PosicaoBoca.getRandom(), 300);
						sobrancelhas.trocaSobrancelhaTemporaria(MovimentoSobrancelha.getRandom(), 2000);
					}
				} else if (rnd < 0.8) {
					if (nivelComportamentoAleatorio >= 6) {
						if (!trocandoSequenciaTemporaria) {
							int danceNum = (Random.nextInt(2));
							carregaSequenciaExpressaoAtual("Danca" + danceNum, 2, false);
						}
					}
				}

			} else {
				tempoComportamentoAleatorio += delta;
			}
		}

		if (trocandoPosMaos) {
			if (!movingMaoD && !movingMaoE) {
				trocandoPosMaos = false;
			}
		} else {
			if (listTrocaPosMaosPendente.size() > 0) {
				ClassTrocaPosMaos cPosMaos = listTrocaPosMaosPendente.removeFirst();
				trocaPosicaoMaos(cPosMaos.pM, cPosMaos.velocidadeMovimentoD, cPosMaos.velocidadeMovimentoE, cPosMaos.riscarD, cPosMaos.riscarE);
			}
		}

		if (trocandoExpressao) {
			if (!trocandoPosMaos && !olhos.getTrocandoOlho() && !boca.getTrocandoBoca()) {
				trocandoExpressao = false;
			}
		} else {
			if (listExpressaoPendente.size() > 0) {
				trocaExpressao(listExpressaoPendente.removeFirst());
			}
		}

		if (trocandoSequencia && !trocandoExpressao) {
			//setMessageBox("trocando sequencia..tempoContSequenciaExpressao = " + tempoContSequenciaExpressao + ", tempoProximaSequenciaExpressao = " + tempoProximaSequenciaExpressao);
			if (tempoContSequenciaExpressao >= tempoProximaSequenciaExpressao) {
				//setMessageBox("contNumSeqExpressao = " + contNumSeqExpressao);
				//Window.alert("contNumSeqExpressao = " + contNumSeqExpressao);
				if (contNumSeqExpressao < sequenciaExpressaoAtual.getListExpressao().size()) {
					//setMessageBox("nome_sequencia: [" + sequenciaExpressaoAtual.getListExpressao().get(contNumSeqExpressao).getNome() + "]");
					trocaExpressao(sequenciaExpressaoAtual.getListExpressao().get(contNumSeqExpressao));
					//listExpressaoPendente.add(sequenciaExpressaoAtual.getListExpressao().get(contNumSeqExpressao));
					tempoProximaSequenciaExpressao = sequenciaExpressaoAtual.getListTempoLoop().get(contNumSeqExpressao); 
					contNumSeqExpressao++;
				} else {
					trocandoSequencia = false;
					if (sequenciaExpressaoAtual.getReestart()) {
						//contNumSeqExpressao = 0;
						if (listSequenciaExpressaoDBPendente.size() == 0) {
							// se nao ha outra sequencia pendente entao continua repetindo esta sequencia
							//setMessageBox("Restart! FrameRestart = " + sequenciaExpressaoAtual.getFrameRestart());
							//Window.alert("Restart! FrameRestart = " + sequenciaExpressaoAtual.getFrameRestart());
							listSequenciaExpressaoDBPendente.add(new SequenciaExpressaoPendente(sequenciaExpressaoAtual, sequenciaExpressaoAtual.getFrameRestart(), sequenciaExpressaoAtual.getListTempoLoop().get(sequenciaExpressaoAtual.getListTempoLoop().size() - 1)));
							//trocaSequenciaExpressao(sequenciaExpressaoAtual, );
						}
					}
				}
				tempoContSequenciaExpressao = 0;
			} else {
				tempoContSequenciaExpressao += delta;
			}
		} else {
			if (listSequenciaExpressaoDBPendente.size() > 0) {
				SequenciaExpressaoPendente seqExpr = listSequenciaExpressaoDBPendente.removeFirst(); 
				trocaSequenciaExpressao(seqExpr.sequenciaExpr, seqExpr.frameInicio, seqExpr.tempoParaIniciar);
			}
		}

		if (!trocandoAvatar && !trocandoSequencia) {
			if (listSetAvatarPendente.size() > 0) {
				AvatarPendente avPend = listSetAvatarPendente.removeFirst();
				setAvatar(avPend.getAvatar(), avPend.getUpdate());
			}
		}

		if (trocandoSequenciaTemporaria) {
			if (tempoTrocaSequenciaTemp > tempoSequenciaTempDest) {
				// volta pra posicao anterior
				trocaSequenciaExpressao(sequenciaExpressaoTemp, 0, 0);
				trocandoSequenciaTemporaria = false;
			} else {
				tempoTrocaSequenciaTemp += delta;
			}
		}
	}

	@Override
	public int updateRate() {
		return 5;
	}

	public void addTmpSequenciaExpr(int tempo, int velocD, int velocE) {
		if (tmpSequenciaExpr == null) {
			tmpSequenciaExpr = new SequenciaExpressaoDB(new ArrayList<ExpressaoDB>(0), new ArrayList<Integer>(0), false, 0, 0);
		}

		expressaoAtual.setVelocidadeD(velocD);
		expressaoAtual.setVelocidadeE(velocE);
		tmpSequenciaExpr.getListExpressao().add(expressaoAtual);
		tmpSequenciaExpr.getListTempoLoop().add(tempo);
		Window.alert("Adicionou a expressao atual com sucesso: " + tmpSequenciaExpr.getListExpressao().size());
	}

	public void addSequenciaExpr(String nome, final int tempo, boolean animar) {

		//setMessageBox("adicionando sequencia:" + nome);
		if (tmpSequenciaExpr == null) {
			tmpSequenciaExpr = new SequenciaExpressaoDB(new ArrayList<ExpressaoDB>(0), new ArrayList<Integer>(0), false, 0, 0);
		}

		expressaoAtual = null;
		carregaExpressaoDB(nome, false);

		class Contador {
			public float cont = 0;		
		};
		final Contador cont = new Contador();

		//Wait
		Timer t = new Timer() {
			@Override
			public void run() {
				if (expressaoAtual != null) {
					tmpSequenciaExpr.getListExpressao().add(expressaoAtual);
					tmpSequenciaExpr.getListTempoLoop().add(tempo);
					//Window.alert("Adicionou a expressao atual com sucesso: " + tmpSequenciaExpr.getListExpressao().size());
					this.cancel();
					setVariavelCarregamento(1);
				} else {
					cont.cont++;
					if (cont.cont >= 50) {
						this.cancel();
						setVariavelCarregamento(-1);
						Window.alert("Erro ao carregar a sequencia temporaria...!");
					}
				}
			}
		};
		t.scheduleRepeating(30);
	}

	public void alteraExpressaoTmp(int mao, int indice, int maoId, int subMaoId, int sobrancelhaId, int estiloOlhoId, int posicaoOlhoId, int estiloBocaId, int posBocaId, float rotacao, int bezierX, int bezierY, int veloc, boolean riscar) {
		//Window.alert("alteraExpressaoTmp = " + mao + ", " + indice + ", " + riscar + ", size D, E = (" + listImgDrawD.size() + ", " + listImgDrawE.size() + ")");
		if (mao == 1) {
			//Window.alert("ok1");
			if (listImgDrawD.size() > indice) {
				//Window.alert("ok2");
				//listImgDrawD.get(indice).exprDB.getPosicaoMaos().setMaoId(maoId);
				listImgDrawD.get(indice).exprDB.getPosicaoMaos().setSubMaoDId(subMaoId);
				listImgDrawD.get(indice).exprDB.getPosicaoMaos().setRotacaoAdicionalMaoD(rotacao);
				listImgDrawD.get(indice).exprDB.getPosicaoMaos().setBezierDX(bezierX);
				listImgDrawD.get(indice).exprDB.getPosicaoMaos().setBezierDY(bezierY);
				listImgDrawD.get(indice).exprDB.setVelocidadeD(veloc);
				listImgDrawD.get(indice).exprDB.setRiscarD(riscar);
				//Window.alert("ok3");
				setMessageBox("salvou AET Direita");
			}
		} else {
			//for (int i = 0; i < listImgDrawE.size(); i++) {
			//	if (listImgDrawE.get(i) != null) {
			//		setMessageBox("riscar [" + i + "] = " + listImgDrawE.get(i).exprDB.getRiscarE() + ", maoId:" + listImgDrawE.get(i).exprDB.getPosicaoMaos().getMaoEId() + ", bocaId: " + listImgDrawE.get(i).exprDB.getBoca().getId() + ", rotE = " + listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE()); // + ", check1:" + (listImgDrawE.get(i) == listImgDrawE.get(indice)) + ", check2: " + (listImgDrawE.get(i).exprDB.getPosicaoMaos() == listImgDrawE.get(indice).exprDB.getPosicaoMaos()));
			//	}
			//}
			if (listImgDrawE.size() > indice) {
				//Window.alert("ok5");
				//listImgDrawE.get(indice).exprDB.getPosicaoMaos().setMaoId(maoId);
				listImgDrawE.get(indice).exprDB.getPosicaoMaos().setSubMaoEId(subMaoId);
				listImgDrawE.get(indice).exprDB.getPosicaoMaos().setRotacaoAdicionalMaoE(rotacao);
				listImgDrawE.get(indice).exprDB.getPosicaoMaos().setBezierEX(bezierX);
				listImgDrawE.get(indice).exprDB.getPosicaoMaos().setBezierEY(bezierY);
				listImgDrawE.get(indice).exprDB.setVelocidadeE(veloc);
				listImgDrawE.get(indice).exprDB.setRiscarE(riscar);
				//Window.alert("ok6");
				setMessageBox("salvou AET Esquerda");
				//for (int i = 0; i < listImgDrawE.size(); i++) {
				//	if (listImgDrawE.get(i) != null) {
				//		setMessageBox("riscar [" + i + "] = " + listImgDrawE.get(i).exprDB.getRiscarE() + ", maoId:" + listImgDrawE.get(i).exprDB.getPosicaoMaos().getMaoEId() + ", bocaId: " + listImgDrawE.get(i).exprDB.getBoca().getId() + ", rotE = " + listImgDrawE.get(i).exprDB.getPosicaoMaos().getRotacaoAdicionalMaoE()); // + ", check1:" + (listImgDrawE.get(i) == listImgDrawE.get(indice)) + ", check2: " + (listImgDrawE.get(i).exprDB.getPosicaoMaos() == listImgDrawE.get(indice).exprDB.getPosicaoMaos()));
				//	}
				//}
			}
		}
		
		if (listImgDrawD.size() > indice) {
			listImgDrawD.get(indice).exprDB.setMovimentoSobrancelha(MovimentoSobrancelha.getMovimentoSobrancelhaId(sobrancelhaId));
			listImgDrawD.get(indice).exprDB.setPosicaoOlhoBoneco(PosicaoOlhoBoneco.getPosicaoOlhoPerId(posicaoOlhoId));
			listImgDrawD.get(indice).exprDB.setPosicaoBoca(PosicaoBoca.getPosicaoBocaPorId(posBocaId));
		}

		if (listImgDrawE.size() > indice) {
			listImgDrawE.get(indice).exprDB.setMovimentoSobrancelha(MovimentoSobrancelha.getMovimentoSobrancelhaId(sobrancelhaId));
			listImgDrawE.get(indice).exprDB.setPosicaoOlhoBoneco(PosicaoOlhoBoneco.getPosicaoOlhoPerId(posicaoOlhoId));
			listImgDrawE.get(indice).exprDB.setPosicaoBoca(PosicaoBoca.getPosicaoBocaPorId(posBocaId));
		}
		setMessageBox("salvou Expressao AET!");
	}

	public void removeTmpSequenciaExpr() {
		if (tmpSequenciaExpr != null && tmpSequenciaExpr.getListExpressao().size() > 0) {
			tmpSequenciaExpr.getListExpressao().remove(tmpSequenciaExpr.getListExpressao().size() - 1);
			tmpSequenciaExpr.getListTempoLoop().remove(tmpSequenciaExpr.getListTempoLoop().size() - 1);
		}
	}

	public void playTmpSequenciaExpr() {
		setMessageBox("Playing sequencia temporaria...");
		if (tmpSequenciaExpr != null && tmpSequenciaExpr.getListExpressao().size() > 0) {
			setMessageBox("tmpSequenciaExpr.getListExpressao().size() = " + tmpSequenciaExpr.getListExpressao().size());
			trocaSequenciaExpressao(tmpSequenciaExpr, 0, 0);
		}
	}

	public void setBezierE(int x, int y) {
		bracoE.incrementBezier(x, y);
	}

	public void setBezierD(int x, int y) {
		bracoD.incrementBezier(x, y);
	}

	public void setRotacaoMaoD(float ang, boolean atualizar) {
		rotacaoAdicionalMD = ang;
		if (atualizar) {
			moveMaoD_New(posMDX, posMDY, rotacaoAdicionalMD, false);
		}
	}

	public void setRotacaoMaoE(float ang, boolean atualizar) {
		rotacaoAdicionalME = ang;
		if (atualizar) {
			moveMaoE_New(posMEX, posMEY, rotacaoAdicionalME, false);
		}
	}

	public void setSubMaoD(final int subMaoId, final boolean atualizar) {
 		final Image imgM = assets().getImage("/images/avatar/mao/" + maoD.getMaoId() + "/mao" + subMaoId + ".png");

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens da mao...");
			}

			@Override
			public void done() {
				maoD.setImage(imgM);
				maoD.setSubMaoId(subMaoId);
				imgMaoD = imgM;
				//setMessageBox("Carregou a maoD com sucesso...maoId:" + maoId);
				if (atualizar) {
					moveMaoD_New(posMDX, posMDY, rotacaoAdicionalMD, false);
				}
			}
		});
		as.add(imgM);
		as.start();
	}

	public void setSubMaoE(final int subMaoId, final boolean atualizar) {
		final Image imgM = assets().getImage("/images/avatar/mao/" + maoE.getMaoId() + "/mao" + subMaoId + ".png"); 

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens da mao...");
			}

			@Override
			public void done() {
				maoE.setImage(imgM);
				maoE.setSubMaoId(subMaoId);
				imgMaoE = imgM;
				//setMessageBox("Carregou a maoE com sucesso...maoId:" + maoId);
				if (atualizar) {
					moveMaoE_New(posMEX, posMEY, rotacaoAdicionalME, false);
				}
			}
		});
		as.add(imgM);
		as.start();
	}

	public void setEstiloMao(final int estiloMaoId, final boolean atualizar) {
		final Image imgMD = assets().getImage("/images/avatar/mao/" + estiloMaoId + "/mao" + maoD.getSubMaoId() + ".png");
		final Image imgME = assets().getImage("/images/avatar/mao/" + estiloMaoId + "/mao" + maoE.getSubMaoId() + ".png");

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens da mao...");
			}

			@Override
			public void done() {
				maoE.setImage(imgME);
				maoE.setMaoId(estiloMaoId);
				imgMaoE = imgME;
				maoD.setImage(imgMD);
				maoD.setMaoId(estiloMaoId);
				imgMaoD = imgMD;

				//setMessageBox("Carregou a maoE com sucesso...maoId:" + maoId);
				if (atualizar) {
					moveMaoD_New(posMDX, posMDY, rotacaoAdicionalMD, false);
					moveMaoE_New(posMEX, posMEY, rotacaoAdicionalME, false);
				}
			}
		});
		as.add(imgMD);
		as.add(imgME);
		as.start();
	}

	public void setMaoD(final int maoId, final int subMaoId, final boolean atualizar) {
		final Image imgMD = assets().getImage("/images/avatar/mao/" + maoId + "/mao" + subMaoId + ".png");

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens da mao...");
			}

			@Override
			public void done() {
				maoD.setImage(imgMD);
				maoD.setMaoId(maoId);
				maoD.setSubMaoId(subMaoId);
				imgMaoD = imgMD;

				//setMessageBox("Carregou a maoE com sucesso...maoId:" + maoId);
				if (atualizar) {
					moveMaoD_New(posMDX, posMDY, rotacaoAdicionalMD, false);
				}
			}
		});
		as.add(imgMD);
		as.start();
	}

	public void setMaoE(final int maoId, final int subMaoId, final boolean atualizar) {
		final Image imgME = assets().getImage("/images/avatar/mao/" + maoId + "/mao" + subMaoId + ".png");

		AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
			@Override
			public void error(Throwable e) {
				setMessageBox("Erro ao carregar as imagens da mao...");
			}

			@Override
			public void done() {
				maoE.setImage(imgME);
				maoE.setMaoId(maoId);
				maoE.setSubMaoId(subMaoId);
				imgMaoE = imgME;

				//setMessageBox("Carregou a maoE com sucesso...maoId:" + maoId);
				if (atualizar) {
					moveMaoE_New(posMDX, posMDY, rotacaoAdicionalMD, false);
				}
			}
		});
		as.add(imgME);
		as.start();
	}

	public void trocaPosicaoMaos(final PosicaoMaos pM) {
		if (!trocandoPosMaos) {
			trocandoPosMaos = true;
			//Window.alert("maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD() + ", rotME=" + pM.getRotacaoAdicionalMaoE());
			imgMaoD = assets().getImage("/images/avatar/mao/mao" + pM.getMaoDId() + ".png");
			maoD.setImage(imgMaoD);
			maoD.setMaoId(pM.getMaoDId());

			imgMaoE = assets().getImage("/images/avatar/mao/mao" + pM.getMaoEId() + ".png");
			maoE.setImage(imgMaoE);
			maoE.setMaoId(pM.getMaoEId());

			//lyMaoD.setImage(maoD.getImage());
			//lyMaoE.setImage(maoE.getImage());

			bracoD.setBezier(pM.getBezierDX(), pM.getBezierDY());
			bracoE.setBezier(pM.getBezierEX(), pM.getBezierEY());

			startMovimentoMaoD(pM.getPosMDX(), pM.getPosMDY(), pM.getRotacaoAdicionalMaoD(), 20, false);
			startMovimentoMaoE(pM.getPosMEX(), pM.getPosMEY(), pM.getRotacaoAdicionalMaoE(), 20, false);

			//Wait
			Timer t = new Timer() {
				@Override
				public void run() {
					if (!movingMaoD && !movingMaoE) {
						trocandoPosMaos = false;
						this.cancel();
					}
				}
			};
			t.scheduleRepeating(30);

		} else {
			//Agenda esta chamama para um período futuro.
			Timer t = new Timer() {
				@Override
				public void run() {
					trocaPosicaoMaos(pM);	
				}
			};
			t.schedule(30);
		}
	}

	public void trocaPosicaoMaos(final PosicaoMaosDB pM, final int velocidadeMovimentoD, final int velocidadeMovimentoE, final boolean riscarD, final boolean riscarE) {
		//Window.alert("maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD() + ", rotME=" + pM.getRotacaoAdicionalMaoE());
		if (!trocandoPosMaos) {
			trocandoPosMaos = true;
			pMaosAtual = pM;

			//setMessageBox("mao ID (D,E) = (" + pM.getMaoDId() + "," + pM.getMaoEId() + ")...");
			final Image imgD = assets().getImage("/images/avatar/mao/" + avatarAtual.getCodParteMao() + "/mao" + pM.getSubMaoDId() + ".png");
			final Image imgE = assets().getImage("/images/avatar/mao/" + avatarAtual.getCodParteMao() + "/mao" + pM.getSubMaoEId() + ".png");

			AssetWatcher as = new AssetWatcher(new AssetWatcher.Listener() {
				@Override
				public void error(Throwable e) {
					setMessageBox("Erro ao carregar as imagens dos pontos...");
				}

				@Override
				public void done() {

					//setMessageBox("image w,h = (" + imgD.width() + "," + imgD.height() + ")...");

					int ajusteEX = (posXBracoE - (xPosBoneco + 50));
					int ajusteEY = (posYBracoE - yPosBoneco - 130);
					int ajusteDX = (posXBracoD - (xPosBoneco + 140));
					int ajusteDY = (posYBracoD - yPosBoneco - 130);

					if (pM.getPosMDX() != -1 && pM.getPosMDY() != -1) {
						//setMessageBox("rodando startMovimentoMaoD...");
						maoD.setImage(imgMaoD = imgD);
						maoD.setMaoId(avatarAtual.getCodParteMao());
						maoD.setSubMaoId(pM.getSubMaoDId());
						bracoD.setBezier(pM.getBezierDX() - ajusteDX, pM.getBezierDY() - ajusteDY);
						startMovimentoMaoD(pM.getPosMDX() - ajusteDX, pM.getPosMDY() - ajusteDY, pM.getRotacaoAdicionalMaoD(), velocidadeMovimentoD, riscarD);
					}
					if (pM.getPosMEX() != -1 && pM.getPosMEY() != -1) {
						//setMessageBox("rodando startMovimentoMaoE...");
						maoE.setImage(imgMaoE = imgE);
						maoE.setMaoId(avatarAtual.getCodParteMao());
						maoE.setSubMaoId(pM.getSubMaoEId());
						bracoE.setBezier(pM.getBezierEX() - ajusteEX, pM.getBezierEY() - ajusteEY);
						//Window.alert("pM.getPosMEX() = " + pM.getPosMEX() + ", xPosBoneco = " + xPosBoneco + ", posXBracoE = " + posXBracoE);
						startMovimentoMaoE(pM.getPosMEX() - ajusteEX, pM.getPosMEY() - ajusteEY, pM.getRotacaoAdicionalMaoE(), velocidadeMovimentoE, riscarE);
					}
					//moveMaoD_New(pM.getPosMDX(), pM.getPosMDY(), pM.getRotacaoAdicionalMaoD(), riscar);
					//moveMaoE_New(pM.getPosMEX(), pM.getPosMEY(), pM.getRotacaoAdicionalMaoE(), riscar);
					//movingMaoD = false;
					//movingMaoE = false;
				}
			});
			as.add(imgD);
			as.add(imgE);
			as.start();

		} else {
			//Agenda esta chamama para um período futuro.
			listTrocaPosMaosPendente.add(new ClassTrocaPosMaos(pM, velocidadeMovimentoD, velocidadeMovimentoE, riscarD, riscarE));
		}
	}

	private void trocaExpressao(Expressao expr) {
		trocaPosicaoMaos(expr.getPosicaoMaos());
		boca.trocaPosicaoBoca(expr.getPosicaoBoca());
		sobrancelhas.trocaMovimentoSobrancelha(expr.getMovimentoSobrancelha());
		olhos.trocaPosicaoOlho(expr.getPosicaoOlhoBoneco());
	}

	private void trocaExpressao(final ExpressaoDB expr) {
		trocandoExpressao = true;
		expressaoAtual = expr;
		trocaPosicaoMaos(expr.getPosicaoMaos(), expr.getVelocidadeD(), expr.getVelocidadeE(), expr.getRiscarD(), expr.getRiscarE());

		boca.trocaPosicaoBoca(expr.getPosicaoBoca());

		sobrancelhas.trocaMovimentoSobrancelha(expr.getMovimentoSobrancelha());
		olhos.trocaPosicaoOlho(expr.getPosicaoOlhoBoneco());
	}

	private void trocaExpressao(int numExpr) {
		System.out.println("numExpr = " + numExpr);
		Expressao expr = Expressao.getExpressaoPerId(numExpr);
		trocaExpressao(expr);
	}

	private void trocaSequencia(final SequenciaExpressao seqExpr) {
		if (!trocandoSequencia) {
			trocandoSequencia = true;
			trocaExpressao(seqExpr.getExprInicial());

			class Contador {
				public float cont = 0;		
			};
			final Contador cont = new Contador();
	
			Timer timerAleatorio = new Timer() {
				@Override
				public void run() {
					if (cont.cont == 0) {
						trocaExpressao(seqExpr.getExprIntermediaria());
						cont.cont++;
					} else if (cont.cont == 1) {
						trocaExpressao(seqExpr.getExprFinal());
						cont.cont++;
					} else {
						trocaExpressao(seqExpr.getExprInicial());
						cont.cont = 0;
					}
					if (cont.cont > 0) {
						this.schedule(seqExpr.getTempoLoop2());
					} else {
						this.cancel();
						trocandoSequencia = false;
					}
				}
			};
			timerAleatorio.schedule(seqExpr.getTempoLoop1());
		} else {
			//Agenda
			Timer t = new Timer() {
				@Override
				public void run() {
					trocaSequencia(seqExpr);
				}
			};
			t.scheduleRepeating(30);
		}
	}

	private void trocaSequenciaExpressao(final SequenciaExpressaoDB seqExpr, int frameInicial, int tempoProximaSequencia) {
		//setMessageBox("trocandoSequencia = " + trocandoSequencia + ", trocandoAvatar = " + trocandoAvatar);
		//Window.alert("trocandoSequencia = " + trocandoSequencia + ", trocandoAvatar = " + trocandoAvatar);
		if (!trocandoSequencia && !trocandoAvatar) {
			contNumSeqExpressao = frameInicial;
			tempoContSequenciaExpressao = 0;
			tempoProximaSequenciaExpressao = tempoProximaSequencia;
			sequenciaExpressaoAtual = seqExpr;
			trocandoSequencia = true;
		} else {
			//Agenda
			listSequenciaExpressaoDBPendente.add(new SequenciaExpressaoPendente(seqExpr, 0, 0));
		}
	}

	public void trocaSequenciaTemporaria(final SequenciaExpressaoDB seqExpr, int tempo) {
		trocandoSequenciaTemporaria = true;
		tempoSequenciaTempDest = tempo;
		tempoTrocaSequenciaTemp = 0;
		sequenciaExpressaoTemp = sequenciaExpressaoAtual;
		trocaSequenciaExpressao(seqExpr, 0, 0);
	}

	public void trocaSequencia(int numSeq) {
		System.out.println("numExpr = " + numSeq);
		SequenciaExpressao seqExpr = SequenciaExpressao.getExpressaoPerId(numSeq);
		trocaSequencia(seqExpr);
	}

	/*
	private void rotationa(final ImageLayer lyImg, final float angulo, final float scaleX, final float scaleY) {

		class Contador {
			public float cont = 0;		
		};

		final Contador cont = new Contador();
		cont.cont = 0;
		final Timer t = new Timer() {

			@Override
			public void run() {
				if (cont.cont <= 1) {
					lyImg.setRotation(cont.cont * angulo);
					cont.cont += 0.1;
					System.out.println("cont=" + cont.cont + ", angulo=" + radiansToDegree(cont.cont * angulo));
				} else {
					lyImg.setScale(scaleX, scaleY);
					this.cancel();
				}
					
			}
		};
		t.scheduleRepeating(100);
	}
	*/

	/*
	public void posiciona(final ImageLayer lyImg, final int posXIni, final int posYIni, final double angulo, final double hip) {
		
		class Contador {
			public float cont = 0;		
		};
		System.out.println("(posXIni, posYIni) = (" + posXIni + ", " + posYIni + "), angulo = " + angulo + ", hip = " + hip);
		final double xlinha = (Math.cos(angulo) * hip);
		final double ylinha = (Math.sin(angulo) * hip); 
		System.out.println("(xlinha, ylinha) = (" + xlinha + ", " + ylinha + ")");
		final Contador cont = new Contador();
		cont.cont = 0;
		final Timer t = new Timer() {

			@Override
			public void run() {
				if (cont.cont <= 1.01) {
					int px = (int)((posXIni * cont.cont) + xlinha);
					int py = (int)((posYIni * cont.cont) + ylinha);
					System.out.println("cont=" + cont.cont + ", (px, py) = (" + px + ", " + py + "), angulo=" + radiansToDegree(cont.cont * angulo));
					lyImg.setTranslation(px - (lyImg.width() / 2), py - (lyImg.height() / 2));
					cont.cont += 0.1;
					
				} else {
					this.cancel();
				}
			}
		};
		t.scheduleRepeating(100);
	}
	*/

	private void salvaPosicaoMaoAtual(String nome) {
		PosicaoMaosDB pM = new PosicaoMaosDB(nome, maoD.getSubMaoId(), maoE.getSubMaoId(), posMDX, posMDY, posMEX, posMEY, bracoD.getBezierX(), bracoD.getBezierY(), bracoE.getBezierX(), bracoE.getBezierY(), rotacaoAdicionalMD, rotacaoAdicionalME);
		//Window.alert("salvando...maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD() + ", rotME=" + pM.getRotacaoAdicionalMaoE());
		gravaPosicaoMaos(pM);
	}

	private void salvaSequenciaExpressaoAtual(String nome, boolean reestart, int tempoRestart, int frameRestart) {
		tmpSequenciaExpr.setNome(nome);
		tmpSequenciaExpr.setReestart(reestart);
		tmpSequenciaExpr.setTempoRestart(tempoRestart);
		tmpSequenciaExpr.setFrameRestart(frameRestart);
		Window.alert("FrameRestart = " + frameRestart);
		gravaSequenciaExpressao(tmpSequenciaExpr);
	}

	private void salvaExpressaoDB(String nome, int posOlhoId, int posBocaId, int movSobrancelhaId, int subMaoDId, int subMaoEId, int pMDX, int pMDY, int pMEX, int pMEY, int bDBezierX, int bDBezierY, int bEBezierX, int bEBezierY, float rotAdicionalMD, float rotAdicionalME, int velocD, int velocE, boolean riscarD, boolean riscarE, boolean animar) {
		//Window.alert("salvando..." + nome + ", animar..." + animar);
		PosicaoMaosDB pM = new PosicaoMaosDB("PMao_" + nome, subMaoDId, subMaoEId, pMDX, pMDY, pMEX, pMEY, bDBezierX, bDBezierY, bEBezierX, bEBezierY, rotAdicionalMD, rotAdicionalME);
		//Window.alert("salvando..." + nome + ", animar..." + animar);
		ExpressaoDB exprDB = new ExpressaoDB(nome, pM, PosicaoOlhoBoneco.getPosicaoOlhoPerId(posOlhoId), PosicaoBoca.getPosicaoBocaPorId(posBocaId), MovimentoSobrancelha.getMovimentoSobrancelhaId(movSobrancelhaId), velocD, velocE, riscarD, riscarE, animar);
		//Window.alert("salvando..." + nome + ", animar..." + animar);
		//Window.alert("salvando expressao... maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD() + ", rotME=" + pM.getRotacaoAdicionalMaoE() + ", pOlhoAtual = " + pOlhoAtual.getId() + ", bocaAtual = " + bocaAtual.getId() + ", SobrancelhaAtual = " + movSobrancelhaAtual.getId());
		gravaExpressao(exprDB);
	}

	private void carregaPosicaoMaoAtual(String nome, final int velocD, final int velocE, final boolean riscarD, final boolean riscarE) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<PosicaoMaosDB> callback = new AsyncCallback<PosicaoMaosDB>() {
			@Override
			public void onFailure(Throwable caught) {
				//Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(PosicaoMaosDB pM) {
				if (pM != null) {
					//Window.alert("Carregou a posicaoMao!");
					//Window.alert("maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD());
					trocaPosicaoMaos(pM, velocD, velocE, riscarD, riscarE);
				} else {
					//Window.alert("Erro! Filtro DAO posMaosDB retornou nulo!");	
				}
			}
		};
		System.out.println("carregando PosicaoMaoDB...");
		serviceSupportSvc.carregaPosicaoMaoDB(nome, callback);
	}

	private void carregaExpressaoDB(String nome, final boolean play) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<ExpressaoDB> callback = new AsyncCallback<ExpressaoDB>() {
			@Override
			public void onFailure(Throwable caught) {
				//Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(ExpressaoDB exprDB) {
				if (exprDB != null) {
					//Window.alert("Carregou a Expressao!");
					//Window.alert("maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD());
					//trocaExpressao(exprDB, true);
					if (play) {
						//addFilaExpressao(exprDB);
						listExpressaoPendente.add(exprDB);
					} else {
						expressaoAtual = exprDB;
					}
				} else {
					//Window.alert("Erro! Filtro DAO expressaoDB retornou nulo!");	
				}
			}
		};
		System.out.println("carregando ExpressaoDB...");
		serviceSupportSvc.carregaExpressaoDB(nome, callback);
	}

	private void carregaSequenciaExpressaoAtual(final String nome, final int tipoCarregamento /* 0 - normal, 1 - editar, 2 - sequenciatemp */, boolean atualizar) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<SequenciaExpressaoDB> callback = new AsyncCallback<SequenciaExpressaoDB>() {
			@Override
			public void onFailure(Throwable caught) {
				//Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(SequenciaExpressaoDB seqExpr) {
				if (seqExpr != null) {
					//Window.alert("Carregou a SequenciaExpressao!");
					//Window.alert("maoDId=" + pM.getMaoDId() + ", maoEId=" + pM.getMaoEId() + ", posMDX=" + pM.getPosMDX() + ", posMDY=" + pM.getPosMDY() + ", rotMD=" + pM.getRotacaoAdicionalMaoD());
					if (tipoCarregamento == 1) {
						tmpSequenciaExpr = seqExpr;
						setRecording(true, true);
						for (int i = 0; i < tmpSequenciaExpr.getListExpressao().size(); i++) {
							PosicaoMaosDB posM = tmpSequenciaExpr.getListExpressao().get(i).getPosicaoMaos();
							if (posM.getPosMDX() != -1 && posM.getPosMDY() != -1) {
								colocaPontoTmpExpressao(1, posM.getPosMDX(), posM.getPosMDY(), posM.getSubMaoDId(), tmpSequenciaExpr.getListExpressao().get(i).getMovimentoSobrancelha().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoOlhoBoneco().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoBoca().getId(), tmpSequenciaExpr.getListExpressao().get(i).getRiscarD(), posM.getBezierDX(), posM.getBezierDY(), tmpSequenciaExpr.getListExpressao().get(i).getVelocidadeD(), posM.getRotacaoAdicionalMaoD());
							}
							if (posM.getPosMEX() != -1 && posM.getPosMEY() != -1) {
								colocaPontoTmpExpressao(2, posM.getPosMEX(), posM.getPosMEY(), posM.getSubMaoEId(), tmpSequenciaExpr.getListExpressao().get(i).getMovimentoSobrancelha().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoOlhoBoneco().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoBoca().getId(), tmpSequenciaExpr.getListExpressao().get(i).getRiscarE(), posM.getBezierEX(), posM.getBezierEY(), tmpSequenciaExpr.getListExpressao().get(i).getVelocidadeE(), posM.getRotacaoAdicionalMaoE());
							}
						}
						Window.alert("vai carregar form sequencia..FrameRestart:" + tmpSequenciaExpr.getFrameRestart());
						carregaFormDadosSequencia(tmpSequenciaExpr.getNome(), tmpSequenciaExpr.getReestart(), tmpSequenciaExpr.getTempoRestart(), tmpSequenciaExpr.getFrameRestart());
						//gravaMatrExpressaoDB(tmpSequenciaExpr.getListExpressao());
					} else if (tipoCarregamento == 2) {
						trocaSequenciaTemporaria(seqExpr, 2800);
					} else {
						// normal -> play
						trocandoSequenciaTemporaria = false;
						trocaSequenciaExpressao(seqExpr, 0, 0);
					}

					//Atualiza a base 
					mapSeqExpr.put(nome, seqExpr);
				} else {
					//Window.alert("Erro! Filtro DAO sequenciaExpressaoDB retornou nulo!");	
				}
			}
		};
		System.out.println("carregando ExpressaoDB...");

		if (!atualizar) {
			if (mapSeqExpr.containsKey(nome)) {
				SequenciaExpressaoDB seqTmp = mapSeqExpr.get(nome);
				callback.onSuccess(seqTmp);
				System.out.println("carregou a sequenciaExpressao da base armazenada!!!");
			} else {
				serviceSupportSvc.carregaSequenciaExpressaoDB(nome, callback);
			}
		} else {
			serviceSupportSvc.carregaSequenciaExpressaoDB(nome, callback);
		}
	}

	private void editarSequenciaTemp() {
		//setMessageBox("editar sequencia tmp...");
		if (tmpSequenciaExpr != null) {
			//setMessageBox("tmpSequenciaExpr.size = " + tmpSequenciaExpr.getListExpressao().size());
			setRecording(true, true);
			for (int i = 0; i < tmpSequenciaExpr.getListExpressao().size(); i++) {
				PosicaoMaosDB posM = tmpSequenciaExpr.getListExpressao().get(i).getPosicaoMaos();
				if (posM.getPosMDX() != -1 && posM.getPosMDY() != -1) {
					colocaPontoTmpExpressao(1, posM.getPosMDX(), posM.getPosMDY(), posM.getSubMaoDId(), tmpSequenciaExpr.getListExpressao().get(i).getMovimentoSobrancelha().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoOlhoBoneco().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoBoca().getId(), tmpSequenciaExpr.getListExpressao().get(i).getRiscarD(), posM.getBezierDX(), posM.getBezierDY(), tmpSequenciaExpr.getListExpressao().get(i).getVelocidadeD(), posM.getRotacaoAdicionalMaoD());
				}
				if (posM.getPosMEX() != -1 && posM.getPosMEY() != -1) {
					colocaPontoTmpExpressao(2, posM.getPosMEX(), posM.getPosMEY(), posM.getSubMaoEId(), tmpSequenciaExpr.getListExpressao().get(i).getMovimentoSobrancelha().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoOlhoBoneco().getId(), tmpSequenciaExpr.getListExpressao().get(i).getPosicaoBoca().getId(), tmpSequenciaExpr.getListExpressao().get(i).getRiscarE(), posM.getBezierEX(), posM.getBezierEY(), tmpSequenciaExpr.getListExpressao().get(i).getVelocidadeE(), posM.getRotacaoAdicionalMaoE());
				}
			}
		} else {
			setMessageBox("tmpSequenciaExpr = null");
		}
	}

	private void deletaPosicaoMaoDB(String nome) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (b) {
					Window.alert("deletou a posicaoMao!");
				} else {
					Window.alert("Erro! nao deletou!");	
				}
			}
		};
		System.out.println("deletando PosicaoMaoDB...");
		serviceSupportSvc.deletaPosicaoMaoDB(nome, callback);
	}

	private void deletaTodasExpressoesDB() {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (b) {
					setMessageBox("Deletou todas as expressoes");
				} else {
					Window.alert("Erro! nao deletou!");	
				}
			}
		};
		setMessageBox("deletando todas ExpressoesDB...");
		serviceSupportSvc.deletaTodasExpressoesDB(callback);
	}

	private void deletaTodasPosicoesMaosDB() {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (b) {
					setMessageBox("Deletou todas as posicoes maos");
				} else {
					Window.alert("Erro! nao deletou!");	
				}
			}
		};
		setMessageBox("deletando todas Posicoes MaosDB...");
		serviceSupportSvc.deletaTodasPosicoesMaosDB(callback);
	}

	private void deletaExpressaoDB(String nome) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (b) {
					Window.alert("deletou a Expressao!");
				} else {
					Window.alert("Erro! nao deletou!");	
				}
			}
		};
		System.out.println("deletando ExpressaoDB...");
		serviceSupportSvc.deletaExpressaoDB(nome, callback);
	}

	private void gravaPosicaoMaos(final PosicaoMaosDB pMaoDB) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (!b) {
					Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");	
				} else {
					setMessageBox("Gravou PosMao: " + pMaoDB.getNome());
					//Window.alert("Gravou!");
					//Window.Location.replace("/comparacao/" + comp.getPath(ParametrosSistema.SiteHost.SITE_QUAL_O_MELHOR));
				}
			}
		};
		System.out.println("Salvando posicaoMao...");
		//Window.alert("vai gravar...");
		serviceSupportSvc.gravaPosicaoMao(pMaoDB, callback);
	}

	private void gravaMatrExpressaoDB(final ArrayList<ExpressaoDB> listExprDB) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (!b) {
					Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");	
				} else {
					setMessageBox("Gravou a expressao: ");
					//Window.alert("Gravou!");
					//Window.Location.replace("/comparacao/" + comp.getPath(ParametrosSistema.SiteHost.SITE_QUAL_O_MELHOR));
				}
			}
		};
		System.out.println("Salvando expressao...");
		//Window.alert("vai gravar...");
		serviceSupportSvc.gravaMatrExpressao(listExprDB, callback);
	}

	private void gravaExpressao(ExpressaoDB exprDB) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (!b) {
					Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");	
				} else {
					setMessageBox("Gravou!");
					//Window.Location.replace("/comparacao/" + comp.getPath(ParametrosSistema.SiteHost.SITE_QUAL_O_MELHOR));
				}
			}
		};
		System.out.println("Salvando expressaoMao...");
		setMessageBox("vai gravar...");
		serviceSupportSvc.gravaExpressao(exprDB, callback);
	}

	private void gravaSequenciaExpressao(SequenciaExpressaoDB seqExprDB) {
		if (serviceSupportSvc == null) {
			serviceSupportSvc = GWT.create(ISessionSuportService.class);
		}

		GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
			@Override
			public void onUncaughtException(Throwable e) {
				e.printStackTrace();
				System.out.println("Excecao nao tratada em Horario Carrega Sessao !!!!!!!!!!");
			}
		});

		AsyncCallback<Boolean> callback = new AsyncCallback<Boolean>() {
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");
			}

			@Override
			public void onSuccess(Boolean b) {
				if (!b) {
					Window.alert("Erro ao tentar gravar! Por favor, aperte a tecla F5 do seu teclado para atualizar!");	
				} else {
					Window.alert("Gravou!");
					//Window.Location.replace("/comparacao/" + comp.getPath(ParametrosSistema.SiteHost.SITE_QUAL_O_MELHOR));
				}
			}
		};
		System.out.println("Salvando sequenciaExpressao...");
		//Window.alert("vai gravar...");
		serviceSupportSvc.gravaSequenciaExpressao(seqExprDB, callback);
	}
}